Repository: knative/client
Pull request #770 (2020-04-01 17:32:54)

Remove the delete propagation flag
In it's current state it now takes me about 25 seconds for the `kn delete`
to complete. Before https://github.com/knative/client/pull/682 it used to be
almost immediate. This is because we now pass in the
`DeletePropagationBackground` flag. I believe this is a mistake, not only
because of the 20+ seconds of additional time to delete things, but IMO
the CLI should talk to the server in the same way regardless of the --wait
flag. That flag should just be a CLI thing to indicate if the user wants the CLI
to wait for the server to complete but not HOW the server should do the delete.

Signed-off-by: Doug Davis <dug@us.ibm.com>



knative-prow-robot: [APPROVALNOTIFIER] This PR is **NOT APPROVED**

This pull-request has been approved by: *<a href="https://github.com/knative/client/pull/770#" title="Author self-approved">duglin</a>*
To complete the [pull request process](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process), please assign **maximilien**
You can assign the PR to them by writing `/assign @maximilien` in a comment when ready.

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=knative%2Fclient).

<details open>
Needs approval from an approver in each of these files:

- **[OWNERS](https://github.com/knative/client/blob/master/OWNERS)**

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":["maximilien"]} -->
dsimansk: It was introduced as a part of synchronous delete operation to ensure all dependant resources are deleted for the service and we wait in-sync for the service resource to be gone.
- `DeletePropagationBackground` is added for `--no-wait` and shouldn't cause any blocking. Afaik, it should be cluster default behaviour, but I do agree we could pass empty value to ensure server-side is honoured. 
- `DeletePropagationForeground` is added is current default and configured byt `--wait` flag. It's part of synchronous delete operation, otherwise there should be other mechanism to ensure removal of everything related to service.

From my local test `delete --no-wait` is immediate and `delete --wait` takes some time as expected from synchronous operation.  
duglin: I think the biggest issue is that `--no-wait` is not the default for `kn` so the new 20+second delay I was seeing was very noticeable/unexpected and gave me a bad UX. Perhaps just changing the default would be sufficient

However, I still wonder if `--no-wait` should change what we send to the server. I suspect many folks will think of it the way I did... it's just CLI thingy that only changes how long it takes for my cmd prompt to come back to me - it doesn't change what we tell the server to do - which I believe is true for other `--no-wait` flags on our other commands. If we want the user to be able to influence the DeletePropagation flag then I think we should introduce a flag to specifically allow the user to control that knob w/o overloading the `--no-wait` flag.

But I actually think that's a bit too low level for our CLI. I think the biggest concern for people is "when can I create a new ksvc with the same name w/o getting an error about that name being used?". And the default/DeletePropagationForeground does that. How long it takes to delete other resources that are hidden from the user, and would not influence any subsequent cmd they execute, isn't really that interesting except to a pretty advanced user.
dsimansk: > I think the biggest issue is that --no-wait is not the default for kn so the new 20+second delay I was seeing was very noticeable/unexpected and gave me a bad UX. Perhaps just changing the default would be sufficient

The motivation to have `--wait` as default is alignment to `create` or `update`. Personally, I don't have a strong preference here.

>However, I still wonder if --no-wait should change what we send to the server. I suspect many folks will think of it the way I did... it's just CLI thingy that only changes how long it takes for my cmd prompt to come back to me - it doesn't change what we tell the server to do - which I believe is true for other --no-wait flags on our other commands. If we want the user to be able to influence the DeletePropagation flag then I think we should introduce a flag to specifically allow the user to control that knob w/o overloading the --no-wait flag.

>But I actually think that's a bit too low level for our CLI. I think the biggest concern for people is "when can I create a new ksvc with the same name w/o getting an error about that name being used?". And the default/DeletePropagationForeground does that. How long it takes to delete other resources that are hidden from the user, and would not influence any subsequent cmd they execute, isn't really that interesting except to a pretty advanced user.

The overall goal to have a synchronous delete was to ensure there aren't unexpected race condition between calling CRUD commands in rapid succession, e.g. scripts, E2E tests etc. The case of "service name collision" is on point here as well. I understand `Service` resource as an umbrella that should ensure removal of everything related to prevent unwanted dangling resources. 

Wrt the delete policy flag, I lean strongly toward "too low level" approach. The policy should be opinionated default of synchronous delete. In this case it's part of delete everything strategy.

duglin: > The motivation to have `--wait` as default is alignment to create or update. Personally, I don't have a strong preference here.

Totally agree, but in this case I think we only need to wait for the ksvc to vanish, not the hidden resources.
duglin: Net: 20+ seconds for an out-of-the-box `kn delete` is not good :-) 
rhuss: Kubectl uses cascading delete by default, and we should do that, too. Because if you don't do that, who is going to delete the revisions of a service afterwards ? (afaik, if you don't do a cascading delete those revisions, even when they have an ownerReference will just stay around forever. tbv)

However, I think for `delete` we should really switching to async by default. Because when you delete something you more often don't care anymore about the thing, which is different than when you create something which you might want to use immediate.

So my suggestion is:

* Do cascading delete all the time
* Switch to async delete by default, which can be switched on with `--wait` .We probably will have to adapt the E2E tests, too to add `--wait`
rhuss: My fear is if we don't do a cascade delete we are left with orphaned objects.
duglin:  to be clear... I don't think cascading or not is the issue, either way we'll delete stuff. The question is how we ask the server to do the delete and whether we wait on the CLI side or not.

Switching to `--no-wait` by default is fine, as long as it will at least wait until the ksvc is gone - and that's always been quick for me and what `kn` used to do. I think the issue here is whether kn's `--wait` flag is just a CLI thing or not because we're mixing two concepts into one with the current code base. 

I'll repeat what I said above:
>However, I still wonder if --no-wait should change what we send to the server. I suspect many folks will think of it the way I did... it's just CLI thingy that only changes how long it takes for my cmd prompt to come back to me - it doesn't change what we tell the server to do - which I believe is true for other --no-wait flags on our other commands. If we want the user to be able to influence the DeletePropagation flag then I think we should introduce a flag to specifically allow the user to control that knob w/o overloading the --no-wait flag.

I'd recommend that we keep `--wait` controlling how long the CLI waits for the server to complete it's task - strictly a CLI-side flag.  We can then discuss a second flag to indicate what that "task" is - meaning is it what it used to do (background delete propagation), or is it a foreground delete.
maximilien: Also @duglin consider adding tests :)
rhuss: For me whether we wait for all objects to be deleted (foreground) or to only the main object to be deleted (background) is also a client concern, there is no different background operation. Serverside the eventual result will be the same, whether its foreground or background deletion (with foreground delete policy relying on the [kubernetes garbage collector](https://kubernetes.io/docs/concepts/workloads/controllers/garbage-collection/#controlling-how-the-garbage-collector-deletes-dependents (), thanks @dsimansk for the link).

So the end result will be the same: The object and all its dependent objects are deleted (the option here is actually not related whether to cascade or not, I misunderstood that).

Its just the way _how_ the client instructs the deletion, so I'm totally fine that this way differs for `--wait` vs `--no-wait`, to make `--no-wait` as fast as possible and `--wait` as safe as possible (important for automated use cases like our e2e tests):

* Use the option that @dismansk has selected for `--wait` (foreground) and `--no-wait` (background), so keep the original code
* However: Make `--no-wait` the default for the reasons mentioned in https://github.com/knative/client/pull/770#issuecomment-607913796 to keep a good interactive UX.

rhuss: > Wouldn't it make more sense to have a `--cascade-delete` or similar flag that does not default to true? Seems like removing that feature completely is not a step forward...

I would do *always* a cascade delete as I don't see the use case for non-cascade delete on the abstraction level of `kn`. The question is whether we do the cascade delete explicit (foreground) or rely on the k8s garbage collector (background).
duglin: I'm not thrilled with the idea that `--wait` has different semantics based on the CLI cmd. If it means "CLI returns immediately but the server action is the same" for everything except delete then I think that inconsistency is a problem and not an ideal UX.

If you believe that the client might care about how the delete happens then linking it with whether the CLI returns immediately or not would be bad, because this means that someone can't choose 2 of the 4 possible combination of semantics.

In the end, I strongly believe that `kn service delete foo` needs to return as quickly as possible and it means that I can reuse that Ksvc name immediately, like it used to. Forcing a flag to get that semantics would be bad IMO. 

So I'd like to suggest that we deal with that first and then have a discussion around whether, and how, to change the semantics of the delete on the server. I still like a new flag to control that because I do believe linking it with `--wait` is mixing topics/concerns.
knative-metrics-robot: The following is the coverage report on the affected files.
Say `/test pull-knative-client-go-coverage` to re-run this coverage report

File | Old Coverage | New Coverage | Delta
---- |:------------:|:------------:|:-----:
[pkg/kn/commands/wait_flags.go](https://storage.cloud.google.com/knative-prow/pr-logs/pull/knative_client/770/pull-knative-client-go-coverage/1245852512611733507/artifacts/line-cov.html#file0) | 100.0% | 87.5% | -12.5

duglin: /test pull-knative-client-go-coverage
duglin: Updated PR to just set the default to be `--no-wait` per our slack chat

Patch:
diff --git a/CHANGELOG.adoc b/CHANGELOG.adoc
index babe9b32..08f7a34e 100644
--- a/CHANGELOG.adoc
+++ b/CHANGELOG.adoc
@@ -17,12 +17,21 @@
 [cols="1,10,3", options="header", width="100%"]
 |===
 | | Description | PR
-|===
 
 | 🐣
 | Refactor `e2e` common code into `lib/test`
 | https://github.com/knative/client/pull/765[#765]
 
+| 🐛
+| Fix plugin lookup with file ext on Windows
+| https://github.com/knative/client/pull/774[#774]
+
+| 🐛
+| Correct error message when updating service
+| https://github.com/knative/client/pull/778[#778]
+
+|===
+
 ## v0.13.1 (2020-03-25)
 
 [cols="1,10,3", options="header", width="100%"]
diff --git a/README.md b/README.md
index 38089858..fb1c558a 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,11 @@
 # Kn
 
+[![go.dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white)](https://pkg.go.dev/knative.dev/client)
+[![Go Report Card](https://goreportcard.com/badge/knative/client)](https://goreportcard.com/report/knative/client)
+[![Releases](https://img.shields.io/github/release-pre/knative/client.svg)](https://github.com/knative/client/releases)
+[![LICENSE](https://img.shields.io/github/license/knative/client.svg)](https://github.com/knative/client/blob/master/LICENSE)
+[![Slack Status](https://img.shields.io/badge/slack-join_chat-white.svg?logo=slack&style=social)](https://knative.slack.com)
+
 The Knative client `kn` is your door to the [Knative](https://knative.dev)
 world. It allows you to create Knative resources interactively from the command
 line or from within Shell scripts.
diff --git a/docs/cmd/kn_revision_delete.md b/docs/cmd/kn_revision_delete.md
index 5d6f4e2c..1337acb4 100644
--- a/docs/cmd/kn_revision_delete.md
+++ b/docs/cmd/kn_revision_delete.md
@@ -24,7 +24,7 @@ kn revision delete NAME [flags]
       --async              DEPRECATED: please use --no-wait instead. Delete revision and don't wait for it to be deleted.
   -h, --help               help for delete
   -n, --namespace string   Specify the namespace to operate in.
-      --no-wait            Delete revision and don't wait for it to be deleted.
+      --no-wait            Delete revision and don't wait for it to be deleted. (default true)
       --wait-timeout int   Seconds to wait before giving up on waiting for revision to be deleted. (default 600)
 ```
 
diff --git a/docs/cmd/kn_service_delete.md b/docs/cmd/kn_service_delete.md
index 971fd931..6a2aa9f7 100644
--- a/docs/cmd/kn_service_delete.md
+++ b/docs/cmd/kn_service_delete.md
@@ -27,7 +27,7 @@ kn service delete NAME [flags]
       --async              DEPRECATED: please use --no-wait instead. Delete service and don't wait for it to be deleted.
   -h, --help               help for delete
   -n, --namespace string   Specify the namespace to operate in.
-      --no-wait            Delete service and don't wait for it to be deleted.
+      --no-wait            Delete service and don't wait for it to be deleted. (default true)
       --wait-timeout int   Seconds to wait before giving up on waiting for service to be deleted. (default 600)
 ```
 
diff --git a/docs/cmd/kn_source_binding_create.md b/docs/cmd/kn_source_binding_create.md
index 91fba1d1..ed5e0296 100644
--- a/docs/cmd/kn_source_binding_create.md
+++ b/docs/cmd/kn_source_binding_create.md
@@ -7,7 +7,7 @@ Create a sink binding.
 Create a sink binding.
 
 ```
-kn source binding create NAME --subject SCHEDULE --sink SINK --ce-override KEY=VALUE [flags]
+kn source binding create NAME --subject SUBJECT --sink SINK --ce-override KEY=VALUE [flags]
 ```
 
 ### Examples
diff --git a/go.mod b/go.mod
index 7a3a2a35..9f9859c2 100644
--- a/go.mod
+++ b/go.mod
@@ -20,10 +20,10 @@ require (
 	k8s.io/apimachinery v0.17.0
 	k8s.io/cli-runtime v0.17.0
 	k8s.io/client-go v0.17.0
-	knative.dev/eventing v0.13.4
-	knative.dev/pkg v0.0.0-20200323231609-0840da9555a3
-	knative.dev/serving v0.13.1-0.20200324164309-ce10070bb7ef
-	knative.dev/test-infra v0.0.0-20200324183109-d81c66eea4e6
+	knative.dev/eventing v0.13.6
+	knative.dev/pkg v0.0.0-20200406231459-466c676678dd
+	knative.dev/serving v0.13.1-0.20200407135959-877f5a24bf41
+	knative.dev/test-infra v0.0.0-20200406223059-a7b18bf0c37b
 	sigs.k8s.io/yaml v1.1.0
 )
 
diff --git a/go.sum b/go.sum
index 534375b1..b97bbe03 100644
--- a/go.sum
+++ b/go.sum
@@ -594,14 +594,14 @@ k8s.io/kube-openapi v0.0.0-20191107075043-30be4d16710a/go.mod h1:1TqjTSzOxsLGIKf
 k8s.io/legacy-cloud-providers v0.17.0/go.mod h1:DdzaepJ3RtRy+e5YhNtrCYwlgyK87j/5+Yfp0L9Syp8=
 k8s.io/utils v0.0.0-20191114184206-e782cd3c129f h1:GiPwtSzdP43eI1hpPCbROQCCIgCuiMMNF8YUVLF3vJo=
 k8s.io/utils v0.0.0-20191114184206-e782cd3c129f/go.mod h1:sZAwmy6armz5eXlNoLmJcl4F1QuKu7sr+mFQ0byX7Ew=
-knative.dev/eventing v0.13.4 h1:UqTsfNza4BX5W0+KDoCjPOa+mkU4idE+HolqG7SdN0w=
-knative.dev/eventing v0.13.4/go.mod h1:UxweNv8yXhsdHJitcb9R6rmfNaUD2DFi9GWwNRyIs58=
-knative.dev/pkg v0.0.0-20200323231609-0840da9555a3 h1:lox+XrjDaw+aJxl5LZ7e+NO9Hj1OWm/ZWyyu8a2rKVI=
-knative.dev/pkg v0.0.0-20200323231609-0840da9555a3/go.mod h1:pgODObA1dTyhNoFxPZTTjNWfx6F0aKsKzn+vaT9XO/Q=
-knative.dev/serving v0.13.1-0.20200324164309-ce10070bb7ef h1:4CWRxXBbhEFS8kw26awitohUBZ5ao4iNWqMUdu/uf98=
-knative.dev/serving v0.13.1-0.20200324164309-ce10070bb7ef/go.mod h1:x2n255JS2XBI39tmjZ8CwTxIf9EKNMCrkVuiOttLRm0=
-knative.dev/test-infra v0.0.0-20200324183109-d81c66eea4e6 h1:cttACHBnpN7b509UJnQV1tCD/ssIIGJhHSdHzpPeMzE=
-knative.dev/test-infra v0.0.0-20200324183109-d81c66eea4e6/go.mod h1:xcdUkMJrLlBswIZqL5zCuBFOC22WIPMQoVX1L35i0vQ=
+knative.dev/eventing v0.13.6 h1:TT2w7qjsMTvYcEfTih7Gzv5Nm0GMLe5Y8dxJG3s1wbM=
+knative.dev/eventing v0.13.6/go.mod h1:UxweNv8yXhsdHJitcb9R6rmfNaUD2DFi9GWwNRyIs58=
+knative.dev/pkg v0.0.0-20200406231459-466c676678dd h1:hmFDW9t22H4nqmVJ1wCGmbvImypGxE8aBBWNCFqr0o8=
+knative.dev/pkg v0.0.0-20200406231459-466c676678dd/go.mod h1:pgODObA1dTyhNoFxPZTTjNWfx6F0aKsKzn+vaT9XO/Q=
+knative.dev/serving v0.13.1-0.20200407135959-877f5a24bf41 h1:Ls1IM8u3i58i2bfgSziT7CjpguTiueZvrix6XhkUVOM=
+knative.dev/serving v0.13.1-0.20200407135959-877f5a24bf41/go.mod h1:x2n255JS2XBI39tmjZ8CwTxIf9EKNMCrkVuiOttLRm0=
+knative.dev/test-infra v0.0.0-20200406223059-a7b18bf0c37b h1:jNJVW/NLALp95kLLaGPkItIMAmH8nia5BYjhsmOCSwI=
+knative.dev/test-infra v0.0.0-20200406223059-a7b18bf0c37b/go.mod h1:xcdUkMJrLlBswIZqL5zCuBFOC22WIPMQoVX1L35i0vQ=
 modernc.org/cc v1.0.0/go.mod h1:1Sk4//wdnYJiUIxnW8ddKpaOJCF37yAdqYnkxUpaYxw=
 modernc.org/golex v1.0.0/go.mod h1:b/QX9oBD/LhixY6NDh+IdGv17hgB+51fET1i2kPSmvk=
 modernc.org/mathutil v1.0.0/go.mod h1:wU0vUrJsVWBZ4P6e7xtFJEhFSNsfRLJ8H458uRjg03k=
diff --git a/pkg/eventing/v1alpha1/client.go b/pkg/eventing/v1alpha1/client.go
index 16037fe7..d77f2d52 100644
--- a/pkg/eventing/v1alpha1/client.go
+++ b/pkg/eventing/v1alpha1/client.go
@@ -62,7 +62,7 @@ func NewKnEventingClient(client client_v1alpha1.EventingV1alpha1Interface, names
 
 //CreateTrigger is used to create an instance of trigger
 func (c *knEventingClient) CreateTrigger(trigger *v1alpha1.Trigger) error {
-	trigger, err := c.client.Triggers(c.namespace).Create(trigger)
+	_, err := c.client.Triggers(c.namespace).Create(trigger)
 	if err != nil {
 		return kn_errors.GetError(err)
 	}
@@ -112,7 +112,7 @@ func (c *knEventingClient) ListTriggers() (*v1alpha1.TriggerList, error) {
 
 //CreateTrigger is used to create an instance of trigger
 func (c *knEventingClient) UpdateTrigger(trigger *v1alpha1.Trigger) error {
-	trigger, err := c.client.Triggers(c.namespace).Update(trigger)
+	_, err := c.client.Triggers(c.namespace).Update(trigger)
 	if err != nil {
 		return kn_errors.GetError(err)
 	}
diff --git a/pkg/kn/commands/describe.go b/pkg/kn/commands/describe.go
index 476cf724..28aee7ac 100644
--- a/pkg/kn/commands/describe.go
+++ b/pkg/kn/commands/describe.go
@@ -158,7 +158,6 @@ func sortConditions(conditions []apis.Condition) []apis.Condition {
 		default:
 			return false
 		}
-		return false
 	})
 	return ret
 }
diff --git a/pkg/kn/commands/plugin/handler.go b/pkg/kn/commands/plugin/handler.go
index 7ee7c4ee..5f8b86a0 100644
--- a/pkg/kn/commands/plugin/handler.go
+++ b/pkg/kn/commands/plugin/handler.go
@@ -60,6 +60,7 @@ func NewDefaultPluginHandler(validPrefixes []string, pluginsDir string, lookupPl
 }
 
 // Lookup implements PluginHandler
+// TODO: The current error handling is not optimal, and some errors may be lost. We should refactor the code in the future.
 func (h *DefaultPluginHandler) Lookup(name string) (string, bool) {
 	for _, prefix := range h.ValidPrefixes {
 		pluginPath := fmt.Sprintf("%s-%s", prefix, name)
@@ -72,10 +73,21 @@ func (h *DefaultPluginHandler) Lookup(name string) (string, bool) {
 
 		pluginDirPluginPath := filepath.Join(pluginDir, pluginPath)
 		_, err = os.Stat(pluginDirPluginPath)
-		if !os.IsNotExist(err) {
+		if err == nil {
 			return pluginDirPluginPath, true
 		}
 
+		// Try to match well-known file extensions on Windows
+		if runtime.GOOS == "windows" {
+			for _, ext := range []string{".bat", ".cmd", ".com", ".exe", ".ps1"} {
+				pathWithExt := pluginDirPluginPath + ext
+				_, err = os.Stat(pathWithExt)
+				if err == nil {
+					return pathWithExt, true
+				}
+			}
+		}
+
 		// No plugins found in pluginsDir, try in PATH of that's an option
 		if h.LookupPluginsInPath {
 			pluginPath, err = exec.LookPath(pluginPath)
diff --git a/pkg/kn/commands/service/delete.go b/pkg/kn/commands/service/delete.go
index 81dc8f96..413c7aea 100644
--- a/pkg/kn/commands/service/delete.go
+++ b/pkg/kn/commands/service/delete.go
@@ -40,7 +40,7 @@ func NewServiceDeleteCommand(p *commands.KnParams) *cobra.Command {
 
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(args) < 1 {
-				return errors.New("requires the service name")
+				return errors.New("'service delete' requires the service name(s)")
 			}
 
 			namespace, err := p.GetNamespace(cmd)
diff --git a/pkg/kn/commands/service/describe.go b/pkg/kn/commands/service/describe.go
index 866c0827..d3041248 100644
--- a/pkg/kn/commands/service/describe.go
+++ b/pkg/kn/commands/service/describe.go
@@ -81,7 +81,7 @@ func NewServiceDescribeCommand(p *commands.KnParams) *cobra.Command {
 		Short: "Show details of a service",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(args) != 1 {
-				return errors.New("'kn service describe' requires name of the service as single argument")
+				return errors.New("'service describe' requires the service name given as single argument")
 			}
 			serviceName := args[0]
 
diff --git a/pkg/kn/commands/service/update.go b/pkg/kn/commands/service/update.go
index b0589e0a..fe82ce23 100644
--- a/pkg/kn/commands/service/update.go
+++ b/pkg/kn/commands/service/update.go
@@ -60,7 +60,7 @@ func NewServiceUpdateCommand(p *commands.KnParams) *cobra.Command {
 		Example: updateExample,
 		RunE: func(cmd *cobra.Command, args []string) (err error) {
 			if len(args) != 1 {
-				return errors.New("requires the service name")
+				return errors.New("'service update' requires the service name given as single argument")
 			}
 
 			namespace, err := p.GetNamespace(cmd)
diff --git a/pkg/kn/commands/source/binding/create.go b/pkg/kn/commands/source/binding/create.go
index 48eb0a1d..89177056 100644
--- a/pkg/kn/commands/source/binding/create.go
+++ b/pkg/kn/commands/source/binding/create.go
@@ -31,7 +31,7 @@ func NewBindingCreateCommand(p *commands.KnParams) *cobra.Command {
 	var sinkFlags flags.SinkFlags
 
 	cmd := &cobra.Command{
-		Use:   "create NAME --subject SCHEDULE --sink SINK --ce-override KEY=VALUE",
+		Use:   "create NAME --subject SUBJECT --sink SINK --ce-override KEY=VALUE",
 		Short: "Create a sink binding.",
 		Example: `
   # Create a sink binding which connects a deployment 'myapp' with a Knative service 'mysvc'
diff --git a/pkg/kn/commands/wait_flags.go b/pkg/kn/commands/wait_flags.go
index ca783685..d92ee6f1 100644
--- a/pkg/kn/commands/wait_flags.go
+++ b/pkg/kn/commands/wait_flags.go
@@ -42,8 +42,15 @@ type WaitFlags struct {
 func (p *WaitFlags) AddConditionWaitFlags(command *cobra.Command, waitTimeoutDefault int, action, what, until string) {
 	waitUsage := fmt.Sprintf("%s %s and don't wait for it to be %s.", action, what, until)
 	//TODO: deprecated flag should be removed in next release
+
+	// Special-case 'delete' command so it comes back to the user immediately
+	noWaitDefault := false
+	if action == "Delete" {
+		noWaitDefault = true
+	}
+
 	command.Flags().BoolVar(&p.Async, "async", false, "DEPRECATED: please use --no-wait instead. "+waitUsage)
-	command.Flags().BoolVar(&p.NoWait, "no-wait", false, waitUsage)
+	command.Flags().BoolVar(&p.NoWait, "no-wait", noWaitDefault, waitUsage)
 
 	timeoutUsage := fmt.Sprintf("Seconds to wait before giving up on waiting for %s to be %s.", what, until)
 	command.Flags().IntVar(&p.TimeoutInSeconds, "wait-timeout", waitTimeoutDefault, timeoutUsage)
diff --git a/pkg/sources/v1alpha2/binding_client.go b/pkg/sources/v1alpha2/binding_client.go
index 406c0cad..d004246f 100644
--- a/pkg/sources/v1alpha2/binding_client.go
+++ b/pkg/sources/v1alpha2/binding_client.go
@@ -66,7 +66,7 @@ func newKnSinkBindingClient(client clientv1alpha2.SinkBindingInterface, namespac
 
 //CreateSinkBinding is used to create an instance of binding
 func (c *knBindingClient) CreateSinkBinding(binding *v1alpha2.SinkBinding) error {
-	binding, err := c.client.Create(binding)
+	_, err := c.client.Create(binding)
 	if err != nil {
 		return knerrors.GetError(err)
 	}
@@ -116,7 +116,7 @@ func (c *knBindingClient) ListSinkBindings() (*v1alpha2.SinkBindingList, error)
 
 //CreateSinkBinding is used to create an instance of binding
 func (c *knBindingClient) UpdateSinkBinding(binding *v1alpha2.SinkBinding) error {
-	binding, err := c.client.Update(binding)
+	_, err := c.client.Update(binding)
 	if err != nil {
 		return knerrors.GetError(err)
 	}
diff --git a/vendor/knative.dev/pkg/apis/condition_set.go b/vendor/knative.dev/pkg/apis/condition_set.go
index 3e1ac5c9..3c0746df 100644
--- a/vendor/knative.dev/pkg/apis/condition_set.go
+++ b/vendor/knative.dev/pkg/apis/condition_set.go
@@ -334,7 +334,7 @@ func (r conditionsImpl) findUnhappyDependent() *Condition {
 	}
 
 	// If something was not initialized.
-	if len(r.dependents) != len(conditions) {
+	if len(r.dependents) > len(conditions) {
 		return &Condition{
 			Status: corev1.ConditionUnknown,
 		}
diff --git a/vendor/knative.dev/pkg/apis/contexts.go b/vendor/knative.dev/pkg/apis/contexts.go
index abb5706a..735c6191 100644
--- a/vendor/knative.dev/pkg/apis/contexts.go
+++ b/vendor/knative.dev/pkg/apis/contexts.go
@@ -198,3 +198,16 @@ func AllowDifferentNamespace(ctx context.Context) context.Context {
 func IsDifferentNamespaceAllowed(ctx context.Context) bool {
 	return ctx.Value(allowDifferentNamespace{}) != nil
 }
+
+// This is attached to contexts passed to webhook interfaces when the user has request DryRun mode.
+type isDryRun struct{}
+
+// WithDryRun is used to indicate that this call is in DryRun mode.
+func WithDryRun(ctx context.Context) context.Context {
+	return context.WithValue(ctx, isDryRun{}, struct{}{})
+}
+
+// IsDryRun indicates that this request is in DryRun mode.
+func IsDryRun(ctx context.Context) bool {
+	return ctx.Value(isDryRun{}) != nil
+}
diff --git a/vendor/knative.dev/pkg/tracker/enqueue.go b/vendor/knative.dev/pkg/tracker/enqueue.go
index a8f02ea6..fc036466 100644
--- a/vendor/knative.dev/pkg/tracker/enqueue.go
+++ b/vendor/knative.dev/pkg/tracker/enqueue.go
@@ -159,7 +159,7 @@ func (i *impl) TrackReference(ref Reference, obj interface{}) error {
 			// doesn't create problems:
 			//    foo, err := lister.Get(key)
 			//    // Later...
-			//    err := tracker.Track(fooRef, parent)
+			//    err := tracker.TrackReference(fooRef, parent)
 			// In this example, "Later" represents a window where "foo" may
 			// have changed or been created while the Track is not active.
 			// The simplest way of eliminating such a window is to call the
@@ -192,7 +192,7 @@ func (i *impl) TrackReference(ref Reference, obj interface{}) error {
 		// doesn't create problems:
 		//    foo, err := lister.Get(key)
 		//    // Later...
-		//    err := tracker.Track(fooRef, parent)
+		//    err := tracker.TrackReference(fooRef, parent)
 		// In this example, "Later" represents a window where "foo" may
 		// have changed or been created while the Track is not active.
 		// The simplest way of eliminating such a window is to call the
diff --git a/vendor/knative.dev/serving/pkg/apis/config/defaults.go b/vendor/knative.dev/serving/pkg/apis/config/defaults.go
index 50a54488..7371e3bd 100644
--- a/vendor/knative.dev/serving/pkg/apis/config/defaults.go
+++ b/vendor/knative.dev/serving/pkg/apis/config/defaults.go
@@ -90,11 +90,11 @@ func NewDefaultsConfigFromMap(data map[string]string) (*Defaults, error) {
 		field: &nc.ContainerConcurrencyMaxLimit,
 	}} {
 		if raw, ok := data[i64.key]; ok {
-			if val, err := strconv.ParseInt(raw, 10, 64); err != nil {
+			val, err := strconv.ParseInt(raw, 10, 64)
+			if err != nil {
 				return nil, err
-			} else {
-				*i64.field = val
 			}
+			*i64.field = val
 		}
 	}
 
@@ -136,9 +136,7 @@ func NewDefaultsConfigFromMap(data map[string]string) (*Defaults, error) {
 		}
 	}
 
-	if raw, ok := data["container-name-template"]; !ok {
-		nc.UserContainerNameTemplate = DefaultUserContainerName
-	} else {
+	if raw, ok := data["container-name-template"]; ok {
 		tmpl, err := template.New("user-container").Parse(raw)
 		if err != nil {
 			return nil, err
diff --git a/vendor/knative.dev/serving/pkg/apis/networking/v1alpha1/serverlessservice_types.go b/vendor/knative.dev/serving/pkg/apis/networking/v1alpha1/serverlessservice_types.go
index 3d2a6427..99499234 100644
--- a/vendor/knative.dev/serving/pkg/apis/networking/v1alpha1/serverlessservice_types.go
+++ b/vendor/knative.dev/serving/pkg/apis/networking/v1alpha1/serverlessservice_types.go
@@ -101,6 +101,11 @@ type ServerlessServiceSpec struct {
 	// The application-layer protocol. Matches `RevisionProtocolType` set on the owning pa/revision.
 	// serving imports networking, so just use string.
 	ProtocolType networking.ProtocolType
+
+	// NumActivators contains number of Activators that this revision should be
+	// assigned.
+	// O means — assign all.
+	NumActivators int32 `json:"numActivators,omitempty"`
 }
 
 // ServerlessServiceStatus describes the current state of the ServerlessService.
diff --git a/vendor/knative.dev/serving/pkg/apis/networking/v1alpha1/serverlessservice_validation.go b/vendor/knative.dev/serving/pkg/apis/networking/v1alpha1/serverlessservice_validation.go
index ebace729..0ee05b2b 100644
--- a/vendor/knative.dev/serving/pkg/apis/networking/v1alpha1/serverlessservice_validation.go
+++ b/vendor/knative.dev/serving/pkg/apis/networking/v1alpha1/serverlessservice_validation.go
@@ -46,6 +46,10 @@ func (spec *ServerlessServiceSpec) Validate(ctx context.Context) *apis.FieldErro
 		all = all.Also(apis.ErrInvalidValue(spec.Mode, "mode"))
 	}
 
+	if spec.NumActivators < 0 {
+		all = all.Also(apis.ErrInvalidValue(spec.NumActivators, "numActivators"))
+	}
+
 	all = all.Also(serving.ValidateNamespacedObjectReference(&spec.ObjectRef).ViaField("objectRef"))
 
 	return all.Also(spec.ProtocolType.Validate(ctx).ViaField("protocolType"))
diff --git a/vendor/knative.dev/serving/pkg/autoscaler/config/config.go b/vendor/knative.dev/serving/pkg/autoscaler/config/config.go
index 5adc8233..1263c6aa 100644
--- a/vendor/knative.dev/serving/pkg/autoscaler/config/config.go
+++ b/vendor/knative.dev/serving/pkg/autoscaler/config/config.go
@@ -80,31 +80,46 @@ type Config struct {
 	PodAutoscalerClass string
 }
 
+func defaultConfig() *Config {
+	return &Config{
+		EnableScaleToZero:                  true,
+		EnableGracefulScaledown:            false,
+		ContainerConcurrencyTargetFraction: defaultTargetUtilization,
+		ContainerConcurrencyTargetDefault:  100,
+		// TODO(#1956): Tune target usage based on empirical data.
+		TargetUtilization:        defaultTargetUtilization,
+		RPSTargetDefault:         200,
+		MaxScaleUpRate:           1000,
+		MaxScaleDownRate:         2,
+		TargetBurstCapacity:      200,
+		PanicWindowPercentage:    10,
+		ActivatorCapacity:        100,
+		PanicThresholdPercentage: 200,
+		StableWindow:             60 * time.Second,
+		ScaleToZeroGracePeriod:   30 * time.Second,
+		TickInterval:             2 * time.Second,
+		PodAutoscalerClass:       autoscaling.KPA,
+	}
+}
+
 // NewConfigFromMap creates a Config from the supplied map
 func NewConfigFromMap(data map[string]string) (*Config, error) {
-	lc := &Config{
-		TargetUtilization: defaultTargetUtilization,
-	}
+	lc := defaultConfig()
 
 	// Process bool fields.
 	for _, b := range []struct {
-		key          string
-		field        *bool
-		defaultValue bool
+		key   string
+		field *bool
 	}{
 		{
-			key:          "enable-scale-to-zero",
-			field:        &lc.EnableScaleToZero,
-			defaultValue: true,
+			key:   "enable-scale-to-zero",
+			field: &lc.EnableScaleToZero,
 		},
 		{
-			key:          "enable-graceful-scaledown",
-			field:        &lc.EnableGracefulScaledown,
-			defaultValue: false,
+			key:   "enable-graceful-scaledown",
+			field: &lc.EnableGracefulScaledown,
 		}} {
-		if raw, ok := data[b.key]; !ok {
-			*b.field = b.defaultValue
-		} else {
+		if raw, ok := data[b.key]; ok {
 			*b.field = strings.EqualFold(raw, "true")
 		}
 	}
@@ -113,51 +128,39 @@ func NewConfigFromMap(data map[string]string) (*Config, error) {
 	for _, f64 := range []struct {
 		key   string
 		field *float64
-		// specified exactly when optional
-		defaultValue float64
 	}{{
-		key:          "max-scale-up-rate",
-		field:        &lc.MaxScaleUpRate,
-		defaultValue: 1000.0,
+		key:   "max-scale-up-rate",
+		field: &lc.MaxScaleUpRate,
 	}, {
-		key:          "max-scale-down-rate",
-		field:        &lc.MaxScaleDownRate,
-		defaultValue: 2.0,
+		key:   "max-scale-down-rate",
+		field: &lc.MaxScaleDownRate,
 	}, {
 		key:   "container-concurrency-target-percentage",
 		field: &lc.ContainerConcurrencyTargetFraction,
-		// TODO(#1956): Tune target usage based on empirical data.
-		defaultValue: defaultTargetUtilization,
 	}, {
-		key:          "container-concurrency-target-default",
-		field:        &lc.ContainerConcurrencyTargetDefault,
-		defaultValue: 100.0,
+		key:   "container-concurrency-target-default",
+		field: &lc.ContainerConcurrencyTargetDefault,
 	}, {
-		key:          "requests-per-second-target-default",
-		field:        &lc.RPSTargetDefault,
-		defaultValue: 200.0,
+		key:   "requests-per-second-target-default",
+		field: &lc.RPSTargetDefault,
 	}, {
-		key:          "target-burst-capacity",
-		field:        &lc.TargetBurstCapacity,
-		defaultValue: 200,
+		key:   "target-burst-capacity",
+		field: &lc.TargetBurstCapacity,
 	}, {
-		key:          "panic-window-percentage",
-		field:        &lc.PanicWindowPercentage,
-		defaultValue: 10.0,
+		key:   "panic-window-percentage",
+		field: &lc.PanicWindowPercentage,
 	}, {
-		key:          "activator-capacity",
-		field:        &lc.ActivatorCapacity,
-		defaultValue: 100.0,
+		key:   "activator-capacity",
+		field: &lc.ActivatorCapacity,
 	}, {
-		key:          "panic-threshold-percentage",
-		field:        &lc.PanicThresholdPercentage,
-		defaultValue: 200.0,
+		key:   "panic-threshold-percentage",
+		field: &lc.PanicThresholdPercentage,
 	}} {
-		if raw, ok := data[f64.key]; !ok {
-			*f64.field = f64.defaultValue
-		} else if val, err := strconv.ParseFloat(raw, 64); err != nil {
-			return nil, err
-		} else {
+		if raw, ok := data[f64.key]; ok {
+			val, err := strconv.ParseFloat(raw, 64)
+			if err != nil {
+				return nil, err
+			}
 			*f64.field = val
 		}
 	}
@@ -172,32 +175,27 @@ func NewConfigFromMap(data map[string]string) (*Config, error) {
 
 	// Process Duration fields
 	for _, dur := range []struct {
-		key          string
-		field        *time.Duration
-		defaultValue time.Duration
+		key   string
+		field *time.Duration
 	}{{
-		key:          "stable-window",
-		field:        &lc.StableWindow,
-		defaultValue: 60 * time.Second,
+		key:   "stable-window",
+		field: &lc.StableWindow,
 	}, {
-		key:          "scale-to-zero-grace-period",
-		field:        &lc.ScaleToZeroGracePeriod,
-		defaultValue: 30 * time.Second,
+		key:   "scale-to-zero-grace-period",
+		field: &lc.ScaleToZeroGracePeriod,
 	}, {
-		key:          "tick-interval",
-		field:        &lc.TickInterval,
-		defaultValue: 2 * time.Second,
+		key:   "tick-interval",
+		field: &lc.TickInterval,
 	}} {
-		if raw, ok := data[dur.key]; !ok {
-			*dur.field = dur.defaultValue
-		} else if val, err := time.ParseDuration(raw); err != nil {
-			return nil, err
-		} else {
+		if raw, ok := data[dur.key]; ok {
+			val, err := time.ParseDuration(raw)
+			if err != nil {
+				return nil, err
+			}
 			*dur.field = val
 		}
 	}
 
-	lc.PodAutoscalerClass = autoscaling.KPA
 	if pac, ok := data["pod-autoscaler-class"]; ok {
 		lc.PodAutoscalerClass = pac
 	}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index a92d5664..1efb22c5 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -465,7 +465,7 @@ k8s.io/kube-openapi/pkg/util/proto
 k8s.io/utils/buffer
 k8s.io/utils/integer
 k8s.io/utils/trace
-# knative.dev/eventing v0.13.4
+# knative.dev/eventing v0.13.6
 knative.dev/eventing/pkg/apis/config
 knative.dev/eventing/pkg/apis/configs
 knative.dev/eventing/pkg/apis/configs/v1alpha1
@@ -497,7 +497,7 @@ knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha2/fake
 knative.dev/eventing/pkg/legacyclient/clientset/versioned/scheme
 knative.dev/eventing/pkg/legacyclient/clientset/versioned/typed/legacysources/v1alpha1
 knative.dev/eventing/pkg/logging
-# knative.dev/pkg v0.0.0-20200323231609-0840da9555a3
+# knative.dev/pkg v0.0.0-20200406231459-466c676678dd
 knative.dev/pkg/apis
 knative.dev/pkg/apis/duck
 knative.dev/pkg/apis/duck/v1
@@ -513,7 +513,7 @@ knative.dev/pkg/logging/logkey
 knative.dev/pkg/profiling
 knative.dev/pkg/ptr
 knative.dev/pkg/tracker
-# knative.dev/serving v0.13.1-0.20200324164309-ce10070bb7ef
+# knative.dev/serving v0.13.1-0.20200407135959-877f5a24bf41
 knative.dev/serving/pkg/apis/autoscaling
 knative.dev/serving/pkg/apis/autoscaling/v1alpha1
 knative.dev/serving/pkg/apis/config
@@ -527,7 +527,7 @@ knative.dev/serving/pkg/autoscaler/config
 knative.dev/serving/pkg/client/clientset/versioned/scheme
 knative.dev/serving/pkg/client/clientset/versioned/typed/serving/v1
 knative.dev/serving/pkg/client/clientset/versioned/typed/serving/v1/fake
-# knative.dev/test-infra v0.0.0-20200324183109-d81c66eea4e6
+# knative.dev/test-infra v0.0.0-20200406223059-a7b18bf0c37b
 knative.dev/test-infra/scripts
 # sigs.k8s.io/kustomize v2.0.3+incompatible
 sigs.k8s.io/kustomize/pkg/commands/build


Test patch:
diff --git a/lib/test/cli.go b/lib/test/cli.go
index 6d07b068..93f37d55 100644
--- a/lib/test/cli.go
+++ b/lib/test/cli.go
@@ -38,6 +38,11 @@ func NewKn() Kn {
 	return Kn{}
 }
 
+// RunNoNamespace the 'kn' CLI with args but no namespace
+func (k Kn) RunNoNamespace(args ...string) KnRunResult {
+	return RunKn("", args)
+}
+
 // Run the 'kn' CLI with args
 func (k Kn) Run(args ...string) KnRunResult {
 	return RunKn(k.namespace, args)
diff --git a/lib/test/result_collector.go b/lib/test/result_collector.go
index c241e726..02661226 100644
--- a/lib/test/result_collector.go
+++ b/lib/test/result_collector.go
@@ -42,18 +42,32 @@ type KnRunResult struct {
 type KnRunResultCollector struct {
 	results    []KnRunResult
 	extraDumps []string
-	t          *testing.T
+
+	t      *testing.T
+	knTest *KnTest
 }
 
 // NewKnRunResultCollector returns a new KnRunResultCollector
-func NewKnRunResultCollector(t *testing.T) *KnRunResultCollector {
+func NewKnRunResultCollector(t *testing.T, knTest *KnTest) *KnRunResultCollector {
 	return &KnRunResultCollector{
 		results:    []KnRunResult{},
 		extraDumps: []string{},
-		t:          t,
+
+		t:      t,
+		knTest: knTest,
 	}
 }
 
+// T returns the *testing.T object
+func (c *KnRunResultCollector) T() *testing.T {
+	return c.t
+}
+
+// KnTest returns the KnTest object
+func (c *KnRunResultCollector) KnTest() *KnTest {
+	return c.knTest
+}
+
 // AssertNoError helper to assert no error on result
 func (c *KnRunResultCollector) AssertNoError(result KnRunResult) {
 	c.results = append(c.results, result)
diff --git a/pkg/kn/commands/service/create_test.go b/pkg/kn/commands/service/create_test.go
index 0ade9c32..548018f1 100644
--- a/pkg/kn/commands/service/create_test.go
+++ b/pkg/kn/commands/service/create_test.go
@@ -143,6 +143,13 @@ func TestServiceCreateWithMultipleImages(t *testing.T) {
 	assert.Assert(t, util.ContainsAll(err.Error(), "\"--image\"", "\"gcr.io/bar/foo:baz\"", "flag", "once"))
 }
 
+func TestServiceCreateWithMultipleNames(t *testing.T) {
+	_, _, _, err := fakeServiceCreate([]string{
+		"service", "create", "foo", "foo1", "--image", "gcr.io/foo/bar:baz", "--no-wait"}, false)
+
+	assert.Assert(t, util.ContainsAll(err.Error(), "'service create' requires the service name given as single argument"))
+}
+
 func TestServiceCreateImageSync(t *testing.T) {
 	action, created, output, err := fakeServiceCreate([]string{
 		"service", "create", "foo", "--image", "gcr.io/foo/bar:baz"}, false)
diff --git a/pkg/kn/commands/service/describe_test.go b/pkg/kn/commands/service/describe_test.go
index 1c45b2e0..0c2bceb8 100644
--- a/pkg/kn/commands/service/describe_test.go
+++ b/pkg/kn/commands/service/describe_test.go
@@ -75,6 +75,16 @@ func TestServiceDescribeBasic(t *testing.T) {
 	r.Validate()
 }
 
+func TestServiceDescribeWithMultipleNames(t *testing.T) {
+	client := knclient.NewMockKnServiceClient(t)
+	r := client.Recorder()
+	createTestService("foo", []string{"rev1"}, goodConditions())
+	_, err := executeServiceCommand(client, "describe", "foo", "foo1")
+
+	assert.Assert(t, util.ContainsAll(err.Error(), "'service describe' requires the service name given as single argument"))
+	r.Validate()
+}
+
 func TestServiceDescribeSad(t *testing.T) {
 	client := knclient.NewMockKnServiceClient(t)
 	r := client.Recorder()
diff --git a/pkg/kn/commands/service/update_test.go b/pkg/kn/commands/service/update_test.go
index bb48aad8..e197684c 100644
--- a/pkg/kn/commands/service/update_test.go
+++ b/pkg/kn/commands/service/update_test.go
@@ -195,11 +195,19 @@ func TestServiceUpdateImage(t *testing.T) {
 func TestServiceUpdateWithMultipleImages(t *testing.T) {
 	orig := newEmptyService()
 	_, _, _, err := fakeServiceUpdate(orig, []string{
-		"service", "create", "foo", "--image", "gcr.io/foo/bar:baz", "--image", "gcr.io/bar/foo:baz", "--no-wait"})
+		"service", "update", "foo", "--image", "gcr.io/foo/bar:baz", "--image", "gcr.io/bar/foo:baz", "--no-wait"})
 
 	assert.Assert(t, util.ContainsAll(err.Error(), "\"--image\"", "\"gcr.io/bar/foo:baz\"", "flag", "once"))
 }
 
+func TestServiceUpdateWithMultipleNames(t *testing.T) {
+	orig := newEmptyService()
+	_, _, _, err := fakeServiceUpdate(orig, []string{
+		"service", "update", "foo", "foo1", "--image", "gcr.io/foo/bar:baz", "--no-wait"})
+
+	assert.Assert(t, util.ContainsAll(err.Error(), "'service update' requires the service name given as single argument"))
+}
+
 func TestServiceUpdateCommand(t *testing.T) {
 	orig := newEmptyService()
 
diff --git a/pkg/kn/commands/wait_flags_test.go b/pkg/kn/commands/wait_flags_test.go
index 9c711d2c..ce6ad000 100644
--- a/pkg/kn/commands/wait_flags_test.go
+++ b/pkg/kn/commands/wait_flags_test.go
@@ -115,3 +115,12 @@ func TestAddWaitUsageMessage(t *testing.T) {
 		t.Error("wrong until message")
 	}
 }
+
+func TestAddWaitUsageDelete(t *testing.T) {
+	flags := &WaitFlags{}
+	cmd := cobra.Command{}
+	flags.AddConditionWaitFlags(&cmd, 60, "Delete", "blub", "deleted")
+	if !strings.Contains(cmd.UsageString(), "deleted. (default true)") {
+		t.Error("Delete has wrong default value for --no-wait")
+	}
+}
diff --git a/test/e2e/basic_workflow_test.go b/test/e2e/basic_workflow_test.go
index cc5e8ba9..129b06e5 100644
--- a/test/e2e/basic_workflow_test.go
+++ b/test/e2e/basic_workflow_test.go
@@ -35,42 +35,44 @@ func TestBasicWorkflow(t *testing.T) {
 		assert.NilError(t, it.Teardown())
 	}()
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
 	t.Log("returns no service before running tests")
-	serviceListEmpty(t, it, r)
+	serviceListEmpty(r)
 
 	t.Log("create hello service and return no error")
-	serviceCreate(t, it, r, "hello")
+	serviceCreate(r, "hello")
 
 	t.Log("return valid info about hello service")
-	serviceList(t, it, r, "hello")
-	serviceDescribe(t, it, r, "hello")
+	serviceList(r, "hello")
+	serviceDescribe(r, "hello")
 
 	t.Log("update hello service's configuration and return no error")
-	serviceUpdate(t, it, r, "hello", "--env", "TARGET=kn", "--port", "8888")
+	serviceUpdate(r, "hello", "--env", "TARGET=kn", "--port", "8888")
 
 	t.Log("create another service and return no error")
-	serviceCreate(t, it, r, "svc2")
+	serviceCreate(r, "svc2")
 
 	t.Log("return a list of revisions associated with hello and svc2 services")
-	revisionListForService(t, it, r, "hello")
-	revisionListForService(t, it, r, "svc2")
+	revisionListForService(r, "hello")
+	revisionListForService(r, "svc2")
 
 	t.Log("describe revision from hello service")
-	revisionDescribe(t, it, r, "hello")
+	revisionDescribe(r, "hello")
 
 	t.Log("delete hello and svc2 services and return no error")
-	serviceDelete(t, it, r, "hello")
-	serviceDelete(t, it, r, "svc2")
+	serviceDelete(r, "hello")
+	serviceDelete(r, "svc2")
 
 	t.Log("return no service after completing tests")
-	serviceListEmpty(t, it, r)
+	serviceListEmpty(r)
 }
 
 func TestWrongCommand(t *testing.T) {
-	r := test.NewKnRunResultCollector(t)
+	it, err := test.NewKnTest()
+	assert.NilError(t, err)
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
 	out := test.Kn{}.Run("source", "apiserver", "noverb", "--tag=0.13")
@@ -85,62 +87,62 @@ func TestWrongCommand(t *testing.T) {
 
 // ==========================================================================
 
-func serviceListEmpty(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector) {
-	out := it.Kn().Run("service", "list")
+func serviceListEmpty(r *test.KnRunResultCollector) {
+	out := r.KnTest().Kn().Run("service", "list")
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAll(out.Stdout, "No services found."))
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, "No services found."))
 }
 
-func serviceCreate(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string) {
-	out := it.Kn().Run("service", "create", serviceName, "--image", test.KnDefaultTestImage)
+func serviceCreate(r *test.KnRunResultCollector, serviceName string) {
+	out := r.KnTest().Kn().Run("service", "create", serviceName, "--image", test.KnDefaultTestImage)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "service", serviceName, "creating", "namespace", it.Kn().Namespace(), "ready"))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "service", serviceName, "creating", "namespace", r.KnTest().Kn().Namespace(), "ready"))
 }
 
-func serviceList(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string) {
-	out := it.Kn().Run("service", "list", serviceName)
+func serviceList(r *test.KnRunResultCollector, serviceName string) {
+	out := r.KnTest().Kn().Run("service", "list", serviceName)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAll(out.Stdout, serviceName))
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, serviceName))
 }
 
-func serviceDescribe(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string) {
-	out := it.Kn().Run("service", "describe", serviceName)
+func serviceDescribe(r *test.KnRunResultCollector, serviceName string) {
+	out := r.KnTest().Kn().Run("service", "describe", serviceName)
 	r.AssertNoError(out)
-	assert.Assert(t, util.ContainsAll(out.Stdout, serviceName, it.Kn().Namespace(), test.KnDefaultTestImage))
-	assert.Assert(t, util.ContainsAll(out.Stdout, "Conditions", "ConfigurationsReady", "Ready", "RoutesReady"))
-	assert.Assert(t, util.ContainsAll(out.Stdout, "Name", "Namespace", "URL", "Age", "Revisions"))
+	assert.Assert(r.T(), util.ContainsAll(out.Stdout, serviceName, r.KnTest().Kn().Namespace(), test.KnDefaultTestImage))
+	assert.Assert(r.T(), util.ContainsAll(out.Stdout, "Conditions", "ConfigurationsReady", "Ready", "RoutesReady"))
+	assert.Assert(r.T(), util.ContainsAll(out.Stdout, "Name", "Namespace", "URL", "Age", "Revisions"))
 }
 
-func serviceUpdate(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string, args ...string) {
+func serviceUpdate(r *test.KnRunResultCollector, serviceName string, args ...string) {
 	fullArgs := append([]string{}, "service", "update", serviceName)
 	fullArgs = append(fullArgs, args...)
-	out := it.Kn().Run(fullArgs...)
+	out := r.KnTest().Kn().Run(fullArgs...)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "updating", "service", serviceName, "ready"))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "updating", "service", serviceName, "ready"))
 }
 
-func serviceDelete(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string) {
-	out := it.Kn().Run("service", "delete", serviceName)
+func serviceDelete(r *test.KnRunResultCollector, serviceName string) {
+	out := r.KnTest().Kn().Run("service", "delete", serviceName)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAll(out.Stdout, "Service", serviceName, "successfully deleted in namespace", it.Kn().Namespace()))
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, "Service", serviceName, "successfully deleted in namespace", r.KnTest().Kn().Namespace()))
 }
 
-func revisionListForService(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string) {
-	out := it.Kn().Run("revision", "list", "-s", serviceName)
+func revisionListForService(r *test.KnRunResultCollector, serviceName string) {
+	out := r.KnTest().Kn().Run("revision", "list", "-s", serviceName)
 	r.AssertNoError(out)
 	outputLines := strings.Split(out.Stdout, "\n")
 	// Ignore the last line because it is an empty string caused by splitting a line break
 	// at the end of the output string
 	for _, line := range outputLines[1 : len(outputLines)-1] {
 		// The last item is the revision status, which should be ready
-		assert.Check(t, util.ContainsAll(line, " "+serviceName+" ", "True"))
+		assert.Check(r.T(), util.ContainsAll(line, " "+serviceName+" ", "True"))
 	}
 }
 
-func revisionDescribe(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string) {
-	revName := findRevision(t, it, r, serviceName)
+func revisionDescribe(r *test.KnRunResultCollector, serviceName string) {
+	revName := findRevision(r, serviceName)
 
-	out := it.Kn().Run("revision", "describe", revName)
+	out := r.KnTest().Kn().Run("revision", "describe", revName)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAll(out.Stdout, revName, it.Kn().Namespace(), serviceName, "++ Ready", "TARGET=kn"))
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, revName, r.KnTest().Kn().Namespace(), serviceName, "++ Ready", "TARGET=kn"))
 }
diff --git a/test/e2e/ping_test.go b/test/e2e/ping_test.go
index 0fd25686..f0f608c5 100644
--- a/test/e2e/ping_test.go
+++ b/test/e2e/ping_test.go
@@ -34,26 +34,26 @@ func TestSourcePing(t *testing.T) {
 		assert.NilError(t, it.Teardown())
 	}()
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
 	t.Log("Creating a testservice")
-	serviceCreate(t, it, r, "testsvc0")
+	serviceCreate(r, "testsvc0")
 
 	t.Log("create Ping sources with a sink to a service")
 
-	pingSourceCreate(t, it, r, "testpingsource0", "* * * * */1", "ping", "svc:testsvc0")
+	pingSourceCreate(r, "testpingsource0", "* * * * */1", "ping", "svc:testsvc0")
 
 	t.Log("delete Ping sources")
-	pingSourceDelete(t, it, r, "testpingsource0")
+	pingSourceDelete(r, "testpingsource0")
 
 	t.Log("create Ping source with a missing sink service")
-	pingSourceCreateMissingSink(t, it, r, "testpingsource1", "* * * * */1", "ping", "svc:unknown")
+	pingSourceCreateMissingSink(r, "testpingsource1", "* * * * */1", "ping", "svc:unknown")
 
 	t.Log("update Ping source sink service")
-	pingSourceCreate(t, it, r, "testpingsource2", "* * * * */1", "ping", "svc:testsvc0")
-	serviceCreate(t, it, r, "testsvc1")
-	pingSourceUpdateSink(t, it, r, "testpingsource2", "svc:testsvc1")
+	pingSourceCreate(r, "testpingsource2", "* * * * */1", "ping", "svc:testsvc0")
+	serviceCreate(r, "testsvc1")
+	pingSourceUpdateSink(r, "testpingsource2", "svc:testsvc1")
 	jpSinkRefNameInSpec := "jsonpath={.spec.sink.ref.name}"
 	out, err := getResourceFieldsWithJSONPath(t, it, "pingsource", "testpingsource2", jpSinkRefNameInSpec)
 	assert.NilError(t, err)
@@ -61,54 +61,54 @@ func TestSourcePing(t *testing.T) {
 
 	t.Log("verify Ping source description")
 	mymsg := "This is a message from Ping."
-	pingSourceCreate(t, it, r, "testpingsource3", "*/1 * * * *", mymsg, "svc:testsvc1")
-	verifyPingSourceDescribe(t, it, r, "testpingsource3", "*/1 * * * *", mymsg, "testsvc1")
+	pingSourceCreate(r, "testpingsource3", "*/1 * * * *", mymsg, "svc:testsvc1")
+	verifyPingSourceDescribe(r, "testpingsource3", "*/1 * * * *", mymsg, "testsvc1")
 }
 
-func pingSourceCreate(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, sourceName string, schedule string, data string, sink string) {
-	out := it.Kn().Run("source", "ping", "create", sourceName,
+func pingSourceCreate(r *test.KnRunResultCollector, sourceName string, schedule string, data string, sink string) {
+	out := r.KnTest().Kn().Run("source", "ping", "create", sourceName,
 		"--schedule", schedule, "--data", data, "--sink", sink)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "ping", "source", sourceName, "created", "namespace", it.Kn().Namespace()))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "ping", "source", sourceName, "created", "namespace", r.KnTest().Kn().Namespace()))
 	r.AssertNoError(out)
 }
 
-func pingSourceDelete(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, sourceName string) {
-	out := it.Kn().Run("source", "ping", "delete", sourceName)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "ping", "source", sourceName, "deleted", "namespace", it.Kn().Namespace()))
+func pingSourceDelete(r *test.KnRunResultCollector, sourceName string) {
+	out := r.KnTest().Kn().Run("source", "ping", "delete", sourceName)
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "ping", "source", sourceName, "deleted", "namespace", r.KnTest().Kn().Namespace()))
 	r.AssertNoError(out)
 
 }
 
-func pingSourceCreateMissingSink(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, sourceName string, schedule string, data string, sink string) {
-	out := it.Kn().Run("source", "ping", "create", sourceName,
+func pingSourceCreateMissingSink(r *test.KnRunResultCollector, sourceName string, schedule string, data string, sink string) {
+	out := r.KnTest().Kn().Run("source", "ping", "create", sourceName,
 		"--schedule", schedule, "--data", data, "--sink", sink)
-	assert.Check(t, util.ContainsAll(out.Stderr, "services.serving.knative.dev", "not found"))
+	assert.Check(r.T(), util.ContainsAll(out.Stderr, "services.serving.knative.dev", "not found"))
 	r.AssertError(out)
 }
 
-func pingSourceUpdateSink(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, sourceName string, sink string) {
-	out := it.Kn().Run("source", "ping", "update", sourceName, "--sink", sink)
-	assert.Check(t, util.ContainsAll(out.Stdout, sourceName, "updated", "namespace", it.Kn().Namespace()))
+func pingSourceUpdateSink(r *test.KnRunResultCollector, sourceName string, sink string) {
+	out := r.KnTest().Kn().Run("source", "ping", "update", sourceName, "--sink", sink)
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, sourceName, "updated", "namespace", r.KnTest().Kn().Namespace()))
 	r.AssertNoError(out)
 }
 
-func pingSourceCreateWithResources(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, sourceName string, schedule string, data string, sink string, sa string, requestcpu string, requestmm string, limitcpu string, limitmm string) {
-	out := it.Kn().Run("source", "ping", "create", sourceName,
+func pingSourceCreateWithResources(r *test.KnRunResultCollector, sourceName string, schedule string, data string, sink string, sa string, requestcpu string, requestmm string, limitcpu string, limitmm string) {
+	out := r.KnTest().Kn().Run("source", "ping", "create", sourceName,
 		"--schedule", schedule, "--data", data, "--sink", sink, "--service-account", sa,
 		"--requests-cpu", requestcpu, "--requests-memory", requestmm, "--limits-cpu", limitcpu, "--limits-memory", limitmm)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "ping", "source", sourceName, "created", "namespace", it.Kn().Namespace()))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "ping", "source", sourceName, "created", "namespace", r.KnTest().Kn().Namespace()))
 	r.AssertNoError(out)
 }
 
-func pingSourceUpdateResources(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, sourceName string, requestcpu string, requestmm string, limitcpu string, limitmm string) {
-	out := it.Kn().Run("source", "ping", "update", sourceName,
+func pingSourceUpdateResources(r *test.KnRunResultCollector, sourceName string, requestcpu string, requestmm string, limitcpu string, limitmm string) {
+	out := r.KnTest().Kn().Run("source", "ping", "update", sourceName,
 		"--requests-cpu", requestcpu, "--requests-memory", requestmm, "--limits-cpu", limitcpu, "--limits-memory", limitmm)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, sourceName, "updated", "namespace", it.Kn().Namespace()))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, sourceName, "updated", "namespace", r.KnTest().Kn().Namespace()))
 	r.AssertNoError(out)
 }
 
-func verifyPingSourceDescribe(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, sourceName string, schedule string, data string, sink string) {
-	out := it.Kn().Run("source", "ping", "describe", sourceName)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, sourceName, schedule, data, sink))
+func verifyPingSourceDescribe(r *test.KnRunResultCollector, sourceName string, schedule string, data string, sink string) {
+	out := r.KnTest().Kn().Run("source", "ping", "describe", sourceName)
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, sourceName, schedule, data, sink))
 	r.AssertNoError(out)
 }
diff --git a/test/e2e/plugins_test.go b/test/e2e/plugins_test.go
index d2631ea5..d893a3e0 100644
--- a/test/e2e/plugins_test.go
+++ b/test/e2e/plugins_test.go
@@ -96,26 +96,31 @@ func TestPluginWithoutLookup(t *testing.T) {
 	pc, oldPath := setupPluginTestConfigWithNewPath(t)
 	defer tearDownWithPath(pc, oldPath)
 
-	r := test.NewKnRunResultCollector(t)
+	it, err := test.NewKnTest()
+	assert.NilError(t, err)
+
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
 	knFlags := []string{fmt.Sprintf("--plugins-dir=%s", pc.knPluginsDir), "--lookup-plugins=false"}
 
 	t.Log("list plugin in --plugins-dir")
-	listPlugin(t, r, knFlags, []string{pc.knPluginPath}, []string{})
+	listPlugin(r, knFlags, []string{pc.knPluginPath}, []string{})
 
 	t.Log("execute plugin in --plugins-dir")
-	runPlugin(t, r, knFlags, "helloe2e", []string{"e2e", "test"}, []string{"Hello Knative, I'm a Kn plugin", "I received arguments: e2e"})
+	runPlugin(r, knFlags, "helloe2e", []string{"e2e", "test"}, []string{"Hello Knative, I'm a Kn plugin", "I received arguments: e2e"})
 
 	t.Log("does not list any other plugin in $PATH")
-	listPlugin(t, r, knFlags, []string{pc.knPluginPath}, []string{pc.knPluginPath2})
+	listPlugin(r, knFlags, []string{pc.knPluginPath}, []string{pc.knPluginPath2})
 
 	t.Log("with --lookup-plugins is true")
 }
 
 func TestPluginWithLookup(t *testing.T) {
+	it, err := test.NewKnTest()
+	assert.NilError(t, err)
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
 	pc := pluginTestConfig{}
@@ -125,28 +130,33 @@ func TestPluginWithLookup(t *testing.T) {
 	knFlags := []string{fmt.Sprintf("--plugins-dir=%s", pc.knPluginsDir), "--lookup-plugins=true"}
 
 	t.Log("list plugin in --plugins-dir")
-	listPlugin(t, r, knFlags, []string{pc.knPluginPath}, []string{pc.knPluginPath2})
+	listPlugin(r, knFlags, []string{pc.knPluginPath}, []string{pc.knPluginPath2})
 
 	t.Log("execute plugin in --plugins-dir")
-	runPlugin(t, r, knFlags, "helloe2e", []string{}, []string{"Hello Knative, I'm a Kn plugin"})
+	runPlugin(r, knFlags, "helloe2e", []string{}, []string{"Hello Knative, I'm a Kn plugin"})
 }
 
 func TestListPluginInPath(t *testing.T) {
+	it, err := test.NewKnTest()
+	assert.NilError(t, err)
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 
 	pc, oldPath := setupPluginTestConfigWithNewPath(t)
 	defer tearDownWithPath(pc, oldPath)
 
 	t.Log("list plugin in $PATH")
 	knFlags := []string{fmt.Sprintf("--plugins-dir=%s", pc.knPluginsDir), "--lookup-plugins=true"}
-	listPlugin(t, r, knFlags, []string{pc.knPluginPath, pc.knPluginPath2}, []string{})
+	listPlugin(r, knFlags, []string{pc.knPluginPath, pc.knPluginPath2}, []string{})
 
 	r.DumpIfFailed()
 }
 
 func TestExecutePluginInPath(t *testing.T) {
-	r := test.NewKnRunResultCollector(t)
+	it, err := test.NewKnTest()
+	assert.NilError(t, err)
+
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
 	pc, oldPath := setupPluginTestConfigWithNewPath(t)
@@ -154,7 +164,7 @@ func TestExecutePluginInPath(t *testing.T) {
 
 	t.Log("execute plugin in $PATH")
 	knFlags := []string{fmt.Sprintf("--plugins-dir=%s", pc.knPluginsDir), "--lookup-plugins=true"}
-	runPlugin(t, r, knFlags, "hello2e2e", []string{}, []string{"Hello Knative, I'm a Kn plugin"})
+	runPlugin(r, knFlags, "hello2e2e", []string{}, []string{"Hello Knative, I'm a Kn plugin"})
 }
 
 func setupPluginTestConfigWithNewPath(t *testing.T) (pluginTestConfig, string) {
@@ -172,16 +182,16 @@ func tearDownWithPath(pc pluginTestConfig, oldPath string) {
 
 // Private
 
-func listPlugin(t *testing.T, r *test.KnRunResultCollector, knFlags []string, expectedPlugins []string, unexpectedPlugins []string) {
+func listPlugin(r *test.KnRunResultCollector, knFlags []string, expectedPlugins []string, unexpectedPlugins []string) {
 	knArgs := append(knFlags, "plugin", "list")
 
 	out := test.Kn{}.Run(knArgs...)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAll(out.Stdout, expectedPlugins...))
-	assert.Check(t, util.ContainsNone(out.Stdout, unexpectedPlugins...))
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, expectedPlugins...))
+	assert.Check(r.T(), util.ContainsNone(out.Stdout, unexpectedPlugins...))
 }
 
-func runPlugin(t *testing.T, r *test.KnRunResultCollector, knFlags []string, pluginName string, args []string, expectedOutput []string) {
+func runPlugin(r *test.KnRunResultCollector, knFlags []string, pluginName string, args []string, expectedOutput []string) {
 	knArgs := append([]string{}, knFlags...)
 	knArgs = append(knArgs, pluginName)
 	knArgs = append(knArgs, args...)
@@ -189,6 +199,6 @@ func runPlugin(t *testing.T, r *test.KnRunResultCollector, knFlags []string, plu
 	out := test.Kn{}.Run(knArgs...)
 	r.AssertNoError(out)
 	for _, output := range expectedOutput {
-		assert.Check(t, util.ContainsAll(out.Stdout, output))
+		assert.Check(r.T(), util.ContainsAll(out.Stdout, output))
 	}
 }
diff --git a/test/e2e/revision_test.go b/test/e2e/revision_test.go
index c6b6abb6..c6b81e68 100644
--- a/test/e2e/revision_test.go
+++ b/test/e2e/revision_test.go
@@ -37,115 +37,115 @@ func TestRevision(t *testing.T) {
 		assert.NilError(t, it.Teardown())
 	}()
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
 	t.Log("create hello service and return no error")
-	serviceCreate(t, it, r, "hello")
+	serviceCreate(r, "hello")
 
 	t.Log("describe revision from hello service with print flags")
-	revName := findRevision(t, it, r, "hello")
-	revisionDescribeWithPrintFlags(t, it, r, revName)
+	revName := findRevision(r, "hello")
+	revisionDescribeWithPrintFlags(r, revName)
 
 	t.Log("update hello service and increase revision count to 2")
-	serviceUpdate(t, it, r, "hello", "--env", "TARGET=kn", "--port", "8888")
+	serviceUpdate(r, "hello", "--env", "TARGET=kn", "--port", "8888")
 
 	t.Log("show a list of revisions sorted by the count of configuration generation")
-	revisionListWithService(t, it, r, "hello")
+	revisionListWithService(r, "hello")
 
 	t.Log("update hello service and increase revision count to 3")
-	serviceUpdate(t, it, r, "hello", "--env", "TARGET=kn", "--port", "8888")
+	serviceUpdate(r, "hello", "--env", "TARGET=kn", "--port", "8888")
 
 	t.Log("delete three revisions with one revision a nonexistent")
-	existRevision1 := findRevisionByGeneration(t, it, r, "hello", 1)
-	existRevision2 := findRevisionByGeneration(t, it, r, "hello", 2)
+	existRevision1 := findRevisionByGeneration(r, "hello", 1)
+	existRevision2 := findRevisionByGeneration(r, "hello", 2)
 	nonexistRevision := "hello-nonexist"
-	revisionMultipleDelete(t, it, r, existRevision1, existRevision2, nonexistRevision)
+	revisionMultipleDelete(r, existRevision1, existRevision2, nonexistRevision)
 
 	t.Log("delete latest revision from hello service and return no error")
-	revName = findRevision(t, it, r, "hello")
-	revisionDelete(t, it, r, revName)
+	revName = findRevision(r, "hello")
+	revisionDelete(r, revName)
 
 	t.Log("delete hello service and return no error")
-	serviceDelete(t, it, r, "hello")
+	serviceDelete(r, "hello")
 }
 
-func revisionListWithService(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceNames ...string) {
+func revisionListWithService(r *test.KnRunResultCollector, serviceNames ...string) {
 	for _, svcName := range serviceNames {
-		confGen := findConfigurationGeneration(t, it, r, svcName)
-		out := it.Kn().Run("revision", "list", "-s", svcName)
+		confGen := findConfigurationGeneration(r, svcName)
+		out := r.KnTest().Kn().Run("revision", "list", "-s", svcName)
 		r.AssertNoError(out)
 
 		outputLines := strings.Split(out.Stdout, "\n")
 		// Ignore the last line because it is an empty string caused by splitting a line break
 		// at the end of the output string
 		for _, line := range outputLines[1 : len(outputLines)-1] {
-			revName := findRevisionByGeneration(t, it, r, svcName, confGen)
-			assert.Check(t, util.ContainsAll(line, revName, svcName, strconv.Itoa(confGen)))
+			revName := findRevisionByGeneration(r, svcName, confGen)
+			assert.Check(r.T(), util.ContainsAll(line, revName, svcName, strconv.Itoa(confGen)))
 			confGen--
 		}
-		if t.Failed() {
-			r.AddDump("service", svcName, it.Kn().Namespace())
+		if r.T().Failed() {
+			r.AddDump("service", svcName, r.KnTest().Kn().Namespace())
 		}
 	}
 }
 
-func revisionDelete(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, revName string) {
-	out := it.Kn().Run("revision", "delete", revName)
-	assert.Check(t, util.ContainsAll(out.Stdout, "Revision", revName, "deleted", "namespace", it.Kn().Namespace()))
+func revisionDelete(r *test.KnRunResultCollector, revName string) {
+	out := r.KnTest().Kn().Run("revision", "delete", revName)
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, "Revision", revName, "deleted", "namespace", r.KnTest().Kn().Namespace()))
 	r.AssertNoError(out)
 }
 
-func revisionMultipleDelete(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, existRevision1, existRevision2, nonexistRevision string) {
-	out := it.Kn().Run("revision", "list")
+func revisionMultipleDelete(r *test.KnRunResultCollector, existRevision1, existRevision2, nonexistRevision string) {
+	out := r.KnTest().Kn().Run("revision", "list")
 	r.AssertNoError(out)
-	assert.Check(t, strings.Contains(out.Stdout, existRevision1), "Required revision1 does not exist")
-	assert.Check(t, strings.Contains(out.Stdout, existRevision2), "Required revision2 does not exist")
+	assert.Check(r.T(), strings.Contains(out.Stdout, existRevision1), "Required revision1 does not exist")
+	assert.Check(r.T(), strings.Contains(out.Stdout, existRevision2), "Required revision2 does not exist")
 
-	out = it.Kn().Run("revision", "delete", existRevision1, existRevision2, nonexistRevision)
+	out = r.KnTest().Kn().Run("revision", "delete", existRevision1, existRevision2, nonexistRevision)
 	r.AssertNoError(out)
 
-	assert.Check(t, util.ContainsAll(out.Stdout, "Revision", existRevision1, "deleted", "namespace", it.Kn().Namespace()), "Failed to get 'deleted' first revision message")
-	assert.Check(t, util.ContainsAll(out.Stdout, "Revision", existRevision2, "deleted", "namespace", it.Kn().Namespace()), "Failed to get 'deleted' second revision message")
-	assert.Check(t, util.ContainsAll(out.Stdout, "revisions.serving.knative.dev", nonexistRevision, "not found"), "Failed to get 'not found' error")
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, "Revision", existRevision1, "deleted", "namespace", r.KnTest().Kn().Namespace()), "Failed to get 'deleted' first revision message")
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, "Revision", existRevision2, "deleted", "namespace", r.KnTest().Kn().Namespace()), "Failed to get 'deleted' second revision message")
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, "revisions.serving.knative.dev", nonexistRevision, "not found"), "Failed to get 'not found' error")
 }
 
-func revisionDescribeWithPrintFlags(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, revName string) {
-	out := it.Kn().Run("revision", "describe", revName, "-o=name")
+func revisionDescribeWithPrintFlags(r *test.KnRunResultCollector, revName string) {
+	out := r.KnTest().Kn().Run("revision", "describe", revName, "-o=name")
 	r.AssertNoError(out)
 	expectedName := fmt.Sprintf("revision.serving.knative.dev/%s", revName)
-	assert.Equal(t, strings.TrimSpace(out.Stdout), expectedName)
+	assert.Equal(r.T(), strings.TrimSpace(out.Stdout), expectedName)
 }
 
-func findRevision(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string) string {
-	out := it.Kn().Run("revision", "list", "-s", serviceName, "-o=jsonpath={.items[0].metadata.name}")
+func findRevision(r *test.KnRunResultCollector, serviceName string) string {
+	out := r.KnTest().Kn().Run("revision", "list", "-s", serviceName, "-o=jsonpath={.items[0].metadata.name}")
 	r.AssertNoError(out)
 	if strings.Contains(out.Stdout, "No resources") {
-		t.Errorf("Could not find revision name.")
+		r.T().Errorf("Could not find revision name.")
 	}
 	return out.Stdout
 }
 
-func findRevisionByGeneration(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string, generation int) string {
-	maxGen := findConfigurationGeneration(t, it, r, serviceName)
-	out := it.Kn().Run("revision", "list", "-s", serviceName,
+func findRevisionByGeneration(r *test.KnRunResultCollector, serviceName string, generation int) string {
+	maxGen := findConfigurationGeneration(r, serviceName)
+	out := r.KnTest().Kn().Run("revision", "list", "-s", serviceName,
 		fmt.Sprintf("-o=jsonpath={.items[%d].metadata.name}", maxGen-generation))
 	r.AssertNoError(out)
 	if strings.Contains(out.Stdout, "No resources found.") {
-		t.Errorf("Could not find revision name.")
+		r.T().Errorf("Could not find revision name.")
 	}
 	return out.Stdout
 }
 
-func findConfigurationGeneration(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string) int {
-	out := it.Kn().Run("revision", "list", "-s", serviceName, "-o=jsonpath={.items[0].metadata.labels.serving\\.knative\\.dev/configurationGeneration}")
+func findConfigurationGeneration(r *test.KnRunResultCollector, serviceName string) int {
+	out := r.KnTest().Kn().Run("revision", "list", "-s", serviceName, "-o=jsonpath={.items[0].metadata.labels.serving\\.knative\\.dev/configurationGeneration}")
 	r.AssertNoError(out)
 	if out.Stdout == "" {
-		t.Errorf("Could not find configuration generation.")
+		r.T().Errorf("Could not find configuration generation.")
 	}
 	confGen, err := strconv.Atoi(out.Stdout)
 	if err != nil {
-		t.Errorf("Invalid type of configuration generation: %s", err)
+		r.T().Errorf("Invalid type of configuration generation: %s", err)
 	}
 
 	return confGen
diff --git a/test/e2e/route_test.go b/test/e2e/route_test.go
index 603e6ea3..66efae9f 100644
--- a/test/e2e/route_test.go
+++ b/test/e2e/route_test.go
@@ -36,64 +36,64 @@ func TestRoute(t *testing.T) {
 		assert.NilError(t, it.Teardown())
 	}()
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
 	t.Log("create hello service and return no error")
-	serviceCreate(t, it, r, "hello")
+	serviceCreate(r, "hello")
 
 	t.Log("return a list of routes")
-	routeList(t, it, r)
+	routeList(r)
 
 	t.Log("return a list of routes associated with hello service")
-	routeListWithArgument(t, it, r, "hello")
+	routeListWithArgument(r, "hello")
 
 	t.Log("return a list of routes associated with hello service with print flags")
-	routeListWithPrintFlags(t, it, r, "hello")
+	routeListWithPrintFlags(r, "hello")
 
 	t.Log("describe route from hello service")
-	routeDescribe(t, it, r, "hello")
+	routeDescribe(r, "hello")
 
 	t.Log("describe route from hello service with print flags")
-	routeDescribeWithPrintFlags(t, it, r, "hello")
+	routeDescribeWithPrintFlags(r, "hello")
 
 	t.Log("delete hello service and return no error")
-	serviceDelete(t, it, r, "hello")
+	serviceDelete(r, "hello")
 }
 
-func routeList(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector) {
-	out := it.Kn().Run("route", "list")
+func routeList(r *test.KnRunResultCollector) {
+	out := r.KnTest().Kn().Run("route", "list")
 
 	expectedHeaders := []string{"NAME", "URL", "READY"}
-	assert.Check(t, util.ContainsAll(out.Stdout, expectedHeaders...))
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, expectedHeaders...))
 	r.AssertNoError(out)
 }
 
-func routeListWithArgument(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, routeName string) {
-	out := it.Kn().Run("route", "list", routeName)
+func routeListWithArgument(r *test.KnRunResultCollector, routeName string) {
+	out := r.KnTest().Kn().Run("route", "list", routeName)
 
-	assert.Check(t, util.ContainsAll(out.Stdout, routeName))
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, routeName))
 	r.AssertNoError(out)
 }
 
-func routeDescribe(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, routeName string) {
-	out := it.Kn().Run("route", "describe", routeName)
+func routeDescribe(r *test.KnRunResultCollector, routeName string) {
+	out := r.KnTest().Kn().Run("route", "describe", routeName)
 
-	assert.Check(t, util.ContainsAll(out.Stdout,
-		routeName, it.Kn().Namespace(), "URL", "Service", "Traffic", "Targets", "Conditions"))
+	assert.Check(r.T(), util.ContainsAll(out.Stdout,
+		routeName, r.KnTest().Kn().Namespace(), "URL", "Service", "Traffic", "Targets", "Conditions"))
 	r.AssertNoError(out)
 }
 
-func routeDescribeWithPrintFlags(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, routeName string) {
-	out := it.Kn().Run("route", "describe", routeName, "-o=name")
+func routeDescribeWithPrintFlags(r *test.KnRunResultCollector, routeName string) {
+	out := r.KnTest().Kn().Run("route", "describe", routeName, "-o=name")
 
 	expectedName := fmt.Sprintf("route.serving.knative.dev/%s", routeName)
-	assert.Equal(t, strings.TrimSpace(out.Stdout), expectedName)
+	assert.Equal(r.T(), strings.TrimSpace(out.Stdout), expectedName)
 	r.AssertNoError(out)
 }
 
-func routeListWithPrintFlags(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, names ...string) {
-	out := it.Kn().Run("route", "list", "-o=jsonpath={.items[*].metadata.name}")
-	assert.Check(t, util.ContainsAll(out.Stdout, names...))
+func routeListWithPrintFlags(r *test.KnRunResultCollector, names ...string) {
+	out := r.KnTest().Kn().Run("route", "list", "-o=jsonpath={.items[*].metadata.name}")
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, names...))
 	r.AssertNoError(out)
 }
diff --git a/test/e2e/service_export_import_apply_test.go b/test/e2e/service_export_import_apply_test.go
index 3630f271..93a4ddb6 100644
--- a/test/e2e/service_export_import_apply_test.go
+++ b/test/e2e/service_export_import_apply_test.go
@@ -44,45 +44,45 @@ func TestServiceExportImportApply(t *testing.T) {
 		assert.NilError(t, it.Teardown())
 	}()
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
 	t.Log("create service with byo revision")
-	serviceCreateWithOptions(t, it, r, "hello", "--revision-name", "rev1")
+	serviceCreateWithOptions(r, "hello", "--revision-name", "rev1")
 
 	t.Log("export service and compare")
-	serviceExport(t, it, r, "hello", getSvc(withName("hello"), withRevisionName("hello-rev1"), withAnnotations()), "-o", "json")
+	serviceExport(r, "hello", getSvc(withName("hello"), withRevisionName("hello-rev1"), withAnnotations()), "-o", "json")
 
 	t.Log("update service - add env variable")
-	serviceUpdateWithOptions(t, it, r, "hello", "--env", "key1=val1", "--revision-name", "rev2", "--no-lock-to-digest")
-	serviceExport(t, it, r, "hello", getSvc(withName("hello"), withRevisionName("hello-rev2"), withEnv("key1", "val1")), "-o", "json")
-	serviceExportWithRevisions(t, it, r, "hello", getSvcListWithOneRevision(), "--with-revisions", "-o", "yaml")
+	serviceUpdateWithOptions(r, "hello", "--env", "key1=val1", "--revision-name", "rev2", "--no-lock-to-digest")
+	serviceExport(r, "hello", getSvc(withName("hello"), withRevisionName("hello-rev2"), withEnv("key1", "val1")), "-o", "json")
+	serviceExportWithRevisions(r, "hello", getSvcListWithOneRevision(), "--with-revisions", "-o", "yaml")
 
 	t.Log("update service with tag and split traffic")
-	serviceUpdateWithOptions(t, it, r, "hello", "--tag", "hello-rev1=candidate", "--traffic", "candidate=2%,@latest=98%")
-	serviceExportWithRevisions(t, it, r, "hello", getSvcListWithTags(), "--with-revisions", "-o", "yaml")
+	serviceUpdateWithOptions(r, "hello", "--tag", "hello-rev1=candidate", "--traffic", "candidate=2%,@latest=98%")
+	serviceExportWithRevisions(r, "hello", getSvcListWithTags(), "--with-revisions", "-o", "yaml")
 
 	t.Log("update service - untag, add env variable and traffic split")
-	serviceUpdateWithOptions(t, it, r, "hello", "--untag", "candidate")
-	serviceUpdateWithOptions(t, it, r, "hello", "--env", "key2=val2", "--revision-name", "rev3", "--traffic", "hello-rev1=30,hello-rev2=30,hello-rev3=40")
-	serviceExportWithRevisions(t, it, r, "hello", getSvcListWOTags(), "--with-revisions", "-o", "yaml")
+	serviceUpdateWithOptions(r, "hello", "--untag", "candidate")
+	serviceUpdateWithOptions(r, "hello", "--env", "key2=val2", "--revision-name", "rev3", "--traffic", "hello-rev1=30,hello-rev2=30,hello-rev3=40")
+	serviceExportWithRevisions(r, "hello", getSvcListWOTags(), "--with-revisions", "-o", "yaml")
 }
 
 // Private methods
 
-func serviceExport(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string, expService servingv1.Service, options ...string) {
+func serviceExport(r *test.KnRunResultCollector, serviceName string, expService servingv1.Service, options ...string) {
 	command := []string{"service", "export", serviceName}
 	command = append(command, options...)
-	out := it.Kn().Run(command...)
-	validateExportedService(t, it, out.Stdout, expService)
+	out := r.KnTest().Kn().Run(command...)
+	validateExportedService(r.T(), r.KnTest(), out.Stdout, expService)
 	r.AssertNoError(out)
 }
 
-func serviceExportWithRevisions(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string, expServiceList servingv1.ServiceList, options ...string) {
+func serviceExportWithRevisions(r *test.KnRunResultCollector, serviceName string, expServiceList servingv1.ServiceList, options ...string) {
 	command := []string{"service", "export", serviceName}
 	command = append(command, options...)
-	out := it.Kn().Run(command...)
-	validateExportedServiceList(t, it, out.Stdout, expServiceList)
+	out := r.KnTest().Kn().Run(command...)
+	validateExportedServiceList(r.T(), r.KnTest(), out.Stdout, expServiceList)
 	r.AssertNoError(out)
 }
 
diff --git a/test/e2e/service_options_test.go b/test/e2e/service_options_test.go
index 3de24a85..985b9ce4 100644
--- a/test/e2e/service_options_test.go
+++ b/test/e2e/service_options_test.go
@@ -41,64 +41,64 @@ func TestServiceOptions(t *testing.T) {
 		assert.NilError(t, it.Teardown())
 	}()
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 
 	t.Log("create and validate service with concurrency options")
 	defer r.DumpIfFailed()
 
-	serviceCreateWithOptions(t, it, r, "svc1", "--concurrency-limit", "250", "--concurrency-target", "300")
-	validateServiceConcurrencyTarget(t, it, r, "svc1", "300")
-	validateServiceConcurrencyLimit(t, it, r, "svc1", "250")
+	serviceCreateWithOptions(r, "svc1", "--concurrency-limit", "250", "--concurrency-target", "300")
+	validateServiceConcurrencyTarget(r, "svc1", "300")
+	validateServiceConcurrencyLimit(r, "svc1", "250")
 
 	t.Log("update and validate service with concurrency limit")
-	serviceUpdate(t, it, r, "svc1", "--concurrency-limit", "300")
-	validateServiceConcurrencyLimit(t, it, r, "svc1", "300")
+	serviceUpdate(r, "svc1", "--concurrency-limit", "300")
+	validateServiceConcurrencyLimit(r, "svc1", "300")
 
 	t.Log("update concurrency options with invalid values for service")
-	out := it.Kn().Run("service", "update", "svc1", "--concurrency-limit", "-1", "--concurrency-target", "0")
+	out := r.KnTest().Kn().Run("service", "update", "svc1", "--concurrency-limit", "-1", "--concurrency-target", "0")
 	r.AssertError(out)
-	assert.Check(t, util.ContainsAll(out.Stderr, "invalid"))
+	assert.Check(r.T(), util.ContainsAll(out.Stderr, "invalid"))
 
 	t.Log("returns steady concurrency options for service")
-	validateServiceConcurrencyLimit(t, it, r, "svc1", "300")
-	validateServiceConcurrencyTarget(t, it, r, "svc1", "300")
+	validateServiceConcurrencyLimit(r, "svc1", "300")
+	validateServiceConcurrencyTarget(r, "svc1", "300")
 
 	t.Log("delete service")
-	serviceDelete(t, it, r, "svc1")
+	serviceDelete(r, "svc1")
 
 	t.Log("create and validate service with min/max scale options ")
-	serviceCreateWithOptions(t, it, r, "svc2", "--min-scale", "1", "--max-scale", "3")
-	validateServiceMinScale(t, it, r, "svc2", "1")
-	validateServiceMaxScale(t, it, r, "svc2", "3")
+	serviceCreateWithOptions(r, "svc2", "--min-scale", "1", "--max-scale", "3")
+	validateServiceMinScale(r, "svc2", "1")
+	validateServiceMaxScale(r, "svc2", "3")
 
 	t.Log("update and validate service with max scale option")
-	serviceUpdate(t, it, r, "svc2", "--max-scale", "2")
-	validateServiceMaxScale(t, it, r, "svc2", "2")
+	serviceUpdate(r, "svc2", "--max-scale", "2")
+	validateServiceMaxScale(r, "svc2", "2")
 
 	t.Log("delete service")
-	serviceDelete(t, it, r, "svc2")
+	serviceDelete(r, "svc2")
 
 	t.Log("create, update and validate service with annotations")
-	serviceCreateWithOptions(t, it, r, "svc3", "--annotation", "alpha=wolf", "--annotation", "brave=horse")
-	validateServiceAnnotations(t, it, r, "svc3", map[string]string{"alpha": "wolf", "brave": "horse"})
-	serviceUpdate(t, it, r, "svc3", "--annotation", "alpha=direwolf", "--annotation", "brave-")
-	validateServiceAnnotations(t, it, r, "svc3", map[string]string{"alpha": "direwolf", "brave": ""})
-	serviceDelete(t, it, r, "svc3")
+	serviceCreateWithOptions(r, "svc3", "--annotation", "alpha=wolf", "--annotation", "brave=horse")
+	validateServiceAnnotations(r, "svc3", map[string]string{"alpha": "wolf", "brave": "horse"})
+	serviceUpdate(r, "svc3", "--annotation", "alpha=direwolf", "--annotation", "brave-")
+	validateServiceAnnotations(r, "svc3", map[string]string{"alpha": "direwolf", "brave": ""})
+	serviceDelete(r, "svc3")
 
 	t.Log("create, update and validate service with autoscale window option")
-	serviceCreateWithOptions(t, it, r, "svc4", "--autoscale-window", "1m")
-	validateAutoscaleWindow(t, it, r, "svc4", "1m")
-	serviceUpdate(t, it, r, "svc4", "--autoscale-window", "15s")
-	validateAutoscaleWindow(t, it, r, "svc4", "15s")
-	serviceDelete(t, it, r, "svc4")
+	serviceCreateWithOptions(r, "svc4", "--autoscale-window", "1m")
+	validateAutoscaleWindow(r, "svc4", "1m")
+	serviceUpdate(r, "svc4", "--autoscale-window", "15s")
+	validateAutoscaleWindow(r, "svc4", "15s")
+	serviceDelete(r, "svc4")
 
 	t.Log("create, update and validate service with cmd and arg options")
-	serviceCreateWithOptions(t, it, r, "svc5", "--cmd", "/go/bin/helloworld")
-	validateContainerField(t, it, r, "svc5", "command", "[/go/bin/helloworld]")
-	serviceUpdate(t, it, r, "svc5", "--arg", "myArg1", "--arg", "--myArg2")
-	validateContainerField(t, it, r, "svc5", "args", "[myArg1 --myArg2]")
-	serviceUpdate(t, it, r, "svc5", "--arg", "myArg1")
-	validateContainerField(t, it, r, "svc5", "args", "[myArg1]")
+	serviceCreateWithOptions(r, "svc5", "--cmd", "/go/bin/helloworld")
+	validateContainerField(r, "svc5", "command", "[/go/bin/helloworld]")
+	serviceUpdate(r, "svc5", "--arg", "myArg1", "--arg", "--myArg2")
+	validateContainerField(r, "svc5", "args", "[myArg1 --myArg2]")
+	serviceUpdate(r, "svc5", "--arg", "myArg1")
+	validateContainerField(r, "svc5", "args", "[myArg1]")
 
 	t.Log("create, update and validate service with user defined")
 	var uid int64 = 1000
@@ -106,83 +106,84 @@ func TestServiceOptions(t *testing.T) {
 		uid, err = strconv.ParseInt(uids, 10, 64)
 		assert.NilError(t, err)
 	}
-	serviceCreateWithOptions(t, it, r, "svc6", "--user", strconv.FormatInt(uid, 10))
-	validateUserID(t, it, r, "svc6", uid)
-	serviceUpdate(t, it, r, "svc6", "--user", strconv.FormatInt(uid+1, 10))
-	validateUserID(t, it, r, "svc6", uid+1)
+
+	serviceCreateWithOptions(r, "svc6", "--user", strconv.FormatInt(uid, 10))
+	validateUserID(r, "svc6", uid)
+	serviceUpdate(r, "svc6", "--user", strconv.FormatInt(uid+1, 10))
+	validateUserID(r, "svc6", uid+1)
 }
 
-func serviceCreateWithOptions(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string, options ...string) {
+func serviceCreateWithOptions(r *test.KnRunResultCollector, serviceName string, options ...string) {
 	command := []string{"service", "create", serviceName, "--image", test.KnDefaultTestImage}
 	command = append(command, options...)
-	out := it.Kn().Run(command...)
-	assert.Check(t, util.ContainsAll(out.Stdout, "service", serviceName, "Creating", "namespace", it.Kn().Namespace(), "Ready"))
+	out := r.KnTest().Kn().Run(command...)
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, "service", serviceName, "Creating", "namespace", r.KnTest().Kn().Namespace(), "Ready"))
 	r.AssertNoError(out)
 }
 
-func validateServiceConcurrencyLimit(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName, concurrencyLimit string) {
+func validateServiceConcurrencyLimit(r *test.KnRunResultCollector, serviceName, concurrencyLimit string) {
 	jsonpath := "jsonpath={.items[0].spec.template.spec.containerConcurrency}"
-	out := it.Kn().Run("service", "list", serviceName, "-o", jsonpath)
-	assert.Equal(t, out.Stdout, concurrencyLimit)
+	out := r.KnTest().Kn().Run("service", "list", serviceName, "-o", jsonpath)
+	assert.Equal(r.T(), out.Stdout, concurrencyLimit)
 	r.AssertNoError(out)
 }
 
-func validateServiceConcurrencyTarget(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName, concurrencyTarget string) {
+func validateServiceConcurrencyTarget(r *test.KnRunResultCollector, serviceName, concurrencyTarget string) {
 	jsonpath := "jsonpath={.items[0].spec.template.metadata.annotations.autoscaling\\.knative\\.dev/target}"
-	out := it.Kn().Run("service", "list", serviceName, "-o", jsonpath)
-	assert.Equal(t, out.Stdout, concurrencyTarget)
+	out := r.KnTest().Kn().Run("service", "list", serviceName, "-o", jsonpath)
+	assert.Equal(r.T(), out.Stdout, concurrencyTarget)
 	r.AssertNoError(out)
 }
 
-func validateAutoscaleWindow(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName, window string) {
+func validateAutoscaleWindow(r *test.KnRunResultCollector, serviceName, window string) {
 	jsonpath := "jsonpath={.items[0].spec.template.metadata.annotations.autoscaling\\.knative\\.dev/window}"
-	out := it.Kn().Run("service", "list", serviceName, "-o", jsonpath)
-	assert.Equal(t, out.Stdout, window)
+	out := r.KnTest().Kn().Run("service", "list", serviceName, "-o", jsonpath)
+	assert.Equal(r.T(), out.Stdout, window)
 	r.AssertNoError(out)
 }
 
-func validateServiceMinScale(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName, minScale string) {
+func validateServiceMinScale(r *test.KnRunResultCollector, serviceName, minScale string) {
 	jsonpath := "jsonpath={.items[0].spec.template.metadata.annotations.autoscaling\\.knative\\.dev/minScale}"
-	out := it.Kn().Run("service", "list", serviceName, "-o", jsonpath)
-	assert.Equal(t, out.Stdout, minScale)
+	out := r.KnTest().Kn().Run("service", "list", serviceName, "-o", jsonpath)
+	assert.Equal(r.T(), out.Stdout, minScale)
 	r.AssertNoError(out)
 }
 
-func validateServiceMaxScale(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName, maxScale string) {
+func validateServiceMaxScale(r *test.KnRunResultCollector, serviceName, maxScale string) {
 	jsonpath := "jsonpath={.items[0].spec.template.metadata.annotations.autoscaling\\.knative\\.dev/maxScale}"
-	out := it.Kn().Run("service", "list", serviceName, "-o", jsonpath)
-	assert.Equal(t, out.Stdout, maxScale)
+	out := r.KnTest().Kn().Run("service", "list", serviceName, "-o", jsonpath)
+	assert.Equal(r.T(), out.Stdout, maxScale)
 	r.AssertNoError(out)
 }
 
-func validateServiceAnnotations(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string, annotations map[string]string) {
+func validateServiceAnnotations(r *test.KnRunResultCollector, serviceName string, annotations map[string]string) {
 	metadataAnnotationsJsonpathFormat := "jsonpath={.metadata.annotations.%s}"
 	templateAnnotationsJsonpathFormat := "jsonpath={.spec.template.metadata.annotations.%s}"
 
 	for k, v := range annotations {
-		out := it.Kn().Run("service", "describe", serviceName, "-o", fmt.Sprintf(metadataAnnotationsJsonpathFormat, k))
-		assert.Equal(t, v, out.Stdout)
+		out := r.KnTest().Kn().Run("service", "describe", serviceName, "-o", fmt.Sprintf(metadataAnnotationsJsonpathFormat, k))
+		assert.Equal(r.T(), v, out.Stdout)
 		r.AssertNoError(out)
 
-		out = it.Kn().Run("service", "describe", serviceName, "-o", fmt.Sprintf(templateAnnotationsJsonpathFormat, k))
-		assert.Equal(t, v, out.Stdout)
+		out = r.KnTest().Kn().Run("service", "describe", serviceName, "-o", fmt.Sprintf(templateAnnotationsJsonpathFormat, k))
+		assert.Equal(r.T(), v, out.Stdout)
 		r.AssertNoError(out)
 	}
 }
 
-func validateContainerField(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName, field, expected string) {
+func validateContainerField(r *test.KnRunResultCollector, serviceName, field, expected string) {
 	jsonpath := fmt.Sprintf("jsonpath={.items[0].spec.template.spec.containers[0].%s}", field)
-	out := it.Kn().Run("service", "list", serviceName, "-o", jsonpath)
-	assert.Equal(t, out.Stdout, expected)
+	out := r.KnTest().Kn().Run("service", "list", serviceName, "-o", jsonpath)
+	assert.Equal(r.T(), out.Stdout, expected)
 	r.AssertNoError(out)
 }
 
-func validateUserID(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string, uid int64) {
-	out := it.Kn().Run("service", "describe", serviceName, "-ojson")
+func validateUserID(r *test.KnRunResultCollector, serviceName string, uid int64) {
+	out := r.KnTest().Kn().Run("service", "describe", serviceName, "-ojson")
 	data := json.NewDecoder(strings.NewReader(out.Stdout))
 	data.UseNumber()
 	var service servingv1.Service
 	err := data.Decode(&service)
-	assert.NilError(t, err)
-	assert.Equal(t, *service.Spec.Template.Spec.Containers[0].SecurityContext.RunAsUser, uid)
+	assert.NilError(r.T(), err)
+	assert.Equal(r.T(), *service.Spec.Template.Spec.Containers[0].SecurityContext.RunAsUser, uid)
 }
diff --git a/test/e2e/service_test.go b/test/e2e/service_test.go
index 21ed78c4..c7e435ba 100644
--- a/test/e2e/service_test.go
+++ b/test/e2e/service_test.go
@@ -37,99 +37,99 @@ func TestService(t *testing.T) {
 		assert.NilError(t, it.Teardown())
 	}()
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
 	t.Log("create hello service, delete, and try to create duplicate and get service already exists error")
-	serviceCreate(t, it, r, "hello")
-	serviceCreatePrivate(t, it, r, "hello-private")
-	serviceCreateDuplicate(t, it, r, "hello-private")
+	serviceCreate(r, "hello")
+	serviceCreatePrivate(r, "hello-private")
+	serviceCreateDuplicate(r, "hello-private")
 
 	t.Log("return valid info about hello service with print flags")
-	serviceDescribeWithPrintFlags(t, it, r, "hello")
+	serviceDescribeWithPrintFlags(r, "hello")
 
 	t.Log("delete hello service repeatedly and get an error")
-	serviceDelete(t, it, r, "hello")
-	serviceDeleteNonexistent(t, it, r, "hello")
+	serviceDelete(r, "hello")
+	serviceDeleteNonexistent(r, "hello")
 
 	t.Log("delete two services with a service nonexistent")
-	serviceCreate(t, it, r, "hello")
-	serviceMultipleDelete(t, it, r, "hello", "bla123")
+	serviceCreate(r, "hello")
+	serviceMultipleDelete(r, "hello", "bla123")
 
 	t.Log("create service private and make public")
-	serviceCreatePrivateUpdatePublic(t, it, r, "hello-private-public")
+	serviceCreatePrivateUpdatePublic(r, "hello-private-public")
 }
 
-func serviceCreatePrivate(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string) {
-	out := it.Kn().Run("service", "create", serviceName,
+func serviceCreatePrivate(r *test.KnRunResultCollector, serviceName string) {
+	out := r.KnTest().Kn().Run("service", "create", serviceName,
 		"--image", test.KnDefaultTestImage, "--cluster-local")
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "service", serviceName, "creating", "namespace", it.Kn().Namespace(), "ready"))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "service", serviceName, "creating", "namespace", r.KnTest().Kn().Namespace(), "ready"))
 
-	out = it.Kn().Run("service", "describe", serviceName, "--verbose")
+	out = r.KnTest().Kn().Run("service", "describe", serviceName, "--verbose")
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, serving.VisibilityLabelKey, serving.VisibilityClusterLocal))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, serving.VisibilityLabelKey, serving.VisibilityClusterLocal))
 }
 
-func serviceCreatePrivateUpdatePublic(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string) {
-	out := it.Kn().Run("service", "create", serviceName,
+func serviceCreatePrivateUpdatePublic(r *test.KnRunResultCollector, serviceName string) {
+	out := r.KnTest().Kn().Run("service", "create", serviceName,
 		"--image", test.KnDefaultTestImage, "--cluster-local")
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "service", serviceName, "creating", "namespace", it.Kn().Namespace(), "ready"))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "service", serviceName, "creating", "namespace", r.KnTest().Kn().Namespace(), "ready"))
 
-	out = it.Kn().Run("service", "describe", serviceName, "--verbose")
+	out = r.KnTest().Kn().Run("service", "describe", serviceName, "--verbose")
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, serving.VisibilityLabelKey, serving.VisibilityClusterLocal))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, serving.VisibilityLabelKey, serving.VisibilityClusterLocal))
 
-	out = it.Kn().Run("service", "update", serviceName,
+	out = r.KnTest().Kn().Run("service", "update", serviceName,
 		"--image", test.KnDefaultTestImage, "--no-cluster-local")
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "service", serviceName, "updated", "namespace", it.Kn().Namespace(), "ready"))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "service", serviceName, "updated", "namespace", r.KnTest().Kn().Namespace(), "ready"))
 
-	out = it.Kn().Run("service", "describe", serviceName, "--verbose")
+	out = r.KnTest().Kn().Run("service", "describe", serviceName, "--verbose")
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsNone(out.Stdout, serving.VisibilityLabelKey, serving.VisibilityClusterLocal))
+	assert.Check(r.T(), util.ContainsNone(out.Stdout, serving.VisibilityLabelKey, serving.VisibilityClusterLocal))
 }
 
-func serviceCreateDuplicate(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string) {
-	out := it.Kn().Run("service", "list", serviceName)
+func serviceCreateDuplicate(r *test.KnRunResultCollector, serviceName string) {
+	out := r.KnTest().Kn().Run("service", "list", serviceName)
 	r.AssertNoError(out)
-	assert.Check(t, strings.Contains(out.Stdout, serviceName), "The service does not exist yet")
+	assert.Check(r.T(), strings.Contains(out.Stdout, serviceName), "The service does not exist yet")
 
-	out = it.Kn().Run("service", "create", serviceName, "--image", test.KnDefaultTestImage)
+	out = r.KnTest().Kn().Run("service", "create", serviceName, "--image", test.KnDefaultTestImage)
 	r.AssertError(out)
-	assert.Check(t, util.ContainsAll(out.Stderr, "the service already exists"))
+	assert.Check(r.T(), util.ContainsAll(out.Stderr, "the service already exists"))
 }
 
-func serviceDescribeWithPrintFlags(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string) {
-	out := it.Kn().Run("service", "describe", serviceName, "-o=name")
+func serviceDescribeWithPrintFlags(r *test.KnRunResultCollector, serviceName string) {
+	out := r.KnTest().Kn().Run("service", "describe", serviceName, "-o=name")
 	r.AssertNoError(out)
 
 	expectedName := fmt.Sprintf("service.serving.knative.dev/%s", serviceName)
-	assert.Equal(t, strings.TrimSpace(out.Stdout), expectedName)
+	assert.Equal(r.T(), strings.TrimSpace(out.Stdout), expectedName)
 }
 
-func serviceDeleteNonexistent(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string) {
-	out := it.Kn().Run("service", "list", serviceName)
+func serviceDeleteNonexistent(r *test.KnRunResultCollector, serviceName string) {
+	out := r.KnTest().Kn().Run("service", "list", serviceName)
 	r.AssertNoError(out)
-	assert.Check(t, !strings.Contains(out.Stdout, serviceName), "The service exists")
+	assert.Check(r.T(), !strings.Contains(out.Stdout, serviceName), "The service exists")
 
-	out = it.Kn().Run("service", "delete", serviceName)
+	out = r.KnTest().Kn().Run("service", "delete", serviceName)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAll(out.Stdout, "hello", "not found"), "Failed to get 'not found' error")
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, "hello", "not found"), "Failed to get 'not found' error")
 }
 
-func serviceMultipleDelete(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, existService, nonexistService string) {
-	out := it.Kn().Run("service", "list")
+func serviceMultipleDelete(r *test.KnRunResultCollector, existService, nonexistService string) {
+	out := r.KnTest().Kn().Run("service", "list")
 	r.AssertNoError(out)
-	assert.Check(t, strings.Contains(out.Stdout, existService), "The service ", existService, " does not exist (but is expected to exist)")
-	assert.Check(t, !strings.Contains(out.Stdout, nonexistService), "The service", nonexistService, " exists (but is supposed to be not)")
+	assert.Check(r.T(), strings.Contains(out.Stdout, existService), "The service ", existService, " does not exist (but is expected to exist)")
+	assert.Check(r.T(), !strings.Contains(out.Stdout, nonexistService), "The service", nonexistService, " exists (but is supposed to be not)")
 
-	out = it.Kn().Run("service", "delete", existService, nonexistService)
+	out = r.KnTest().Kn().Run("service", "delete", existService, nonexistService)
 	r.AssertNoError(out)
 
-	expectedSuccess := fmt.Sprintf(`Service '%s' successfully deleted in namespace '%s'.`, existService, it.Kn().Namespace())
+	expectedSuccess := fmt.Sprintf(`Service '%s' successfully deleted in namespace '%s'.`, existService, r.KnTest().Kn().Namespace())
 	expectedErr := fmt.Sprintf(`services.serving.knative.dev "%s" not found`, nonexistService)
-	assert.Check(t, strings.Contains(out.Stdout, expectedSuccess), "Failed to get 'successfully deleted' message")
-	assert.Check(t, strings.Contains(out.Stdout, expectedErr), "Failed to get 'not found' error")
+	assert.Check(r.T(), strings.Contains(out.Stdout, expectedSuccess), "Failed to get 'successfully deleted' message")
+	assert.Check(r.T(), strings.Contains(out.Stdout, expectedErr), "Failed to get 'not found' error")
 }
diff --git a/test/e2e/sinkprefix_test.go b/test/e2e/sinkprefix_test.go
index 78f52a3d..a6b65856 100644
--- a/test/e2e/sinkprefix_test.go
+++ b/test/e2e/sinkprefix_test.go
@@ -65,7 +65,7 @@ func TestSinkPrefixConfig(t *testing.T) {
 		assert.NilError(t, it.Teardown())
 	}()
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
 	tc := sinkprefixTestConfig{}
@@ -73,9 +73,9 @@ func TestSinkPrefixConfig(t *testing.T) {
 	defer tc.teardown()
 
 	t.Log("Creating a testservice")
-	serviceCreate(t, it, r, "testsvc0")
+	serviceCreate(r, "testsvc0")
 	t.Log("create Ping sources with a sink to hello:testsvc0")
-	pingSourceCreateWithConfig(t, it, r, "testpingsource0", "* * * * */1", "ping", "hello:testsvc0", tc.knConfigPath)
+	pingSourceCreateWithConfig(r, "testpingsource0", "* * * * */1", "ping", "hello:testsvc0", tc.knConfigPath)
 
 	jpSinkRefNameInSpec := "jsonpath={.spec.sink.ref.name}"
 	out, err := getResourceFieldsWithJSONPath(t, it, "pingsource", "testpingsource0", jpSinkRefNameInSpec)
@@ -83,12 +83,12 @@ func TestSinkPrefixConfig(t *testing.T) {
 	assert.Equal(t, out, "testsvc0")
 
 	t.Log("delete Ping sources")
-	pingSourceDelete(t, it, r, "testpingsource0")
+	pingSourceDelete(r, "testpingsource0")
 }
 
-func pingSourceCreateWithConfig(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, sourceName string, schedule string, data string, sink string, config string) {
-	out := it.Kn().Run("source", "ping", "create", sourceName,
+func pingSourceCreateWithConfig(r *test.KnRunResultCollector, sourceName string, schedule string, data string, sink string, config string) {
+	out := r.KnTest().Kn().Run("source", "ping", "create", sourceName,
 		"--schedule", schedule, "--data", data, "--sink", sink, "--config", config)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "ping", "source", sourceName, "created", "namespace", it.Kn().Namespace()))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "ping", "source", sourceName, "created", "namespace", r.KnTest().Kn().Namespace()))
 	r.AssertNoError(out)
 }
diff --git a/test/e2e/source_apiserver_test.go b/test/e2e/source_apiserver_test.go
index 4f0b97ae..1cbd2bc3 100644
--- a/test/e2e/source_apiserver_test.go
+++ b/test/e2e/source_apiserver_test.go
@@ -47,37 +47,37 @@ func TestSourceApiServer(t *testing.T) {
 		assert.NilError(t, err2)
 	}()
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
 	setupForSourceAPIServer(t, it)
-	serviceCreate(t, it, r, "testsvc0")
+	serviceCreate(r, "testsvc0")
 
 	t.Log("create apiserver sources with a sink to a service")
-	apiServerSourceCreate(t, it, r, "testapisource0", "Event:v1:true", "testsa", "svc:testsvc0")
-	apiServerSourceCreate(t, it, r, "testapisource1", "Event:v1", "testsa", "svc:testsvc0")
+	apiServerSourceCreate(r, "testapisource0", "Event:v1:true", "testsa", "svc:testsvc0")
+	apiServerSourceCreate(r, "testapisource1", "Event:v1", "testsa", "svc:testsvc0")
 
 	t.Log("list sources")
-	output := sourceList(t, it, r)
+	output := sourceList(r)
 	assert.Check(t, util.ContainsAll(output, "NAME", "TYPE", "RESOURCE", "SINK", "READY"))
 	assert.Check(t, util.ContainsAll(output, "testapisource0", "ApiServerSource", "apiserversources.sources.knative.dev", "svc:testsvc0"))
 	assert.Check(t, util.ContainsAll(output, "testapisource1", "ApiServerSource", "apiserversources.sources.knative.dev", "svc:testsvc0"))
 
 	t.Log("list sources in YAML format")
-	output = sourceList(t, it, r, "-oyaml")
+	output = sourceList(r, "-oyaml")
 	assert.Check(t, util.ContainsAll(output, "testapisource1", "ApiServerSource", "Service", "testsvc0"))
 
 	t.Log("delete apiserver sources")
-	apiServerSourceDelete(t, it, r, "testapisource0")
-	apiServerSourceDelete(t, it, r, "testapisource1")
+	apiServerSourceDelete(r, "testapisource0")
+	apiServerSourceDelete(r, "testapisource1")
 
 	t.Log("create apiserver source with a missing sink service")
-	apiServerSourceCreateMissingSink(t, it, r, "testapisource2", "Event:v1:true", "testsa", "svc:unknown")
+	apiServerSourceCreateMissingSink(r, "testapisource2", "Event:v1:true", "testsa", "svc:unknown")
 
 	t.Log("update apiserver source sink service")
-	apiServerSourceCreate(t, it, r, "testapisource3", "Event:v1:true", "testsa", "svc:testsvc0")
-	serviceCreate(t, it, r, "testsvc1")
-	apiServerSourceUpdateSink(t, it, r, "testapisource3", "svc:testsvc1")
+	apiServerSourceCreate(r, "testapisource3", "Event:v1:true", "testsa", "svc:testsvc0")
+	serviceCreate(r, "testsvc1")
+	apiServerSourceUpdateSink(r, "testapisource3", "svc:testsvc1")
 	jpSinkRefNameInSpec := "jsonpath={.spec.sink.ref.name}"
 	out, err := getResourceFieldsWithJSONPath(t, it, "apiserversource.sources.knative.dev", "testapisource3", jpSinkRefNameInSpec)
 	assert.NilError(t, err)
@@ -85,22 +85,22 @@ func TestSourceApiServer(t *testing.T) {
 	// TODO(navidshaikh): Verify the source's status with synchronous create/update
 }
 
-func apiServerSourceCreate(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, sourceName string, resources string, sa string, sink string) {
-	out := it.Kn().Run("source", "apiserver", "create", sourceName, "--resource", resources, "--service-account", sa, "--sink", sink)
+func apiServerSourceCreate(r *test.KnRunResultCollector, sourceName string, resources string, sa string, sink string) {
+	out := r.KnTest().Kn().Run("source", "apiserver", "create", sourceName, "--resource", resources, "--service-account", sa, "--sink", sink)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "apiserver", "source", sourceName, "created", "namespace", it.Kn().Namespace()))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "apiserver", "source", sourceName, "created", "namespace", r.KnTest().Kn().Namespace()))
 }
 
-func apiServerSourceCreateMissingSink(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, sourceName string, resources string, sa string, sink string) {
-	out := it.Kn().Run("source", "apiserver", "create", sourceName, "--resource", resources, "--service-account", sa, "--sink", sink)
+func apiServerSourceCreateMissingSink(r *test.KnRunResultCollector, sourceName string, resources string, sa string, sink string) {
+	out := r.KnTest().Kn().Run("source", "apiserver", "create", sourceName, "--resource", resources, "--service-account", sa, "--sink", sink)
 	r.AssertError(out)
-	assert.Check(t, util.ContainsAll(out.Stderr, "services.serving.knative.dev", "not found"))
+	assert.Check(r.T(), util.ContainsAll(out.Stderr, "services.serving.knative.dev", "not found"))
 }
 
-func apiServerSourceDelete(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, sourceName string) {
-	out := it.Kn().Run("source", "apiserver", "delete", sourceName)
+func apiServerSourceDelete(r *test.KnRunResultCollector, sourceName string) {
+	out := r.KnTest().Kn().Run("source", "apiserver", "delete", sourceName)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "apiserver", "source", sourceName, "deleted", "namespace", it.Kn().Namespace()))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "apiserver", "source", sourceName, "deleted", "namespace", r.KnTest().Kn().Namespace()))
 }
 
 func setupForSourceAPIServer(t *testing.T, it *test.KnTest) {
@@ -140,10 +140,10 @@ func tearDownForSourceAPIServer(t *testing.T, it *test.KnTest) error {
 	return nil
 }
 
-func apiServerSourceUpdateSink(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, sourceName string, sink string) {
-	out := it.Kn().Run("source", "apiserver", "update", sourceName, "--sink", sink)
+func apiServerSourceUpdateSink(r *test.KnRunResultCollector, sourceName string, sink string) {
+	out := r.KnTest().Kn().Run("source", "apiserver", "update", sourceName, "--sink", sink)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAll(out.Stdout, sourceName, "updated", "namespace", it.Kn().Namespace()))
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, sourceName, "updated", "namespace", r.KnTest().Kn().Namespace()))
 }
 
 func getResourceFieldsWithJSONPath(t *testing.T, it *test.KnTest, resource, name, jsonpath string) (string, error) {
diff --git a/test/e2e/source_binding_test.go b/test/e2e/source_binding_test.go
index 290be7a1..150ba6de 100644
--- a/test/e2e/source_binding_test.go
+++ b/test/e2e/source_binding_test.go
@@ -34,41 +34,41 @@ func TestSourceBinding(t *testing.T) {
 		assert.NilError(t, it.Teardown())
 	}()
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
-	serviceCreate(t, it, r, "testsvc0")
+	serviceCreate(r, "testsvc0")
 
 	t.Log("create source binding")
-	sourceBindingCreate(t, it, r, "my-binding0", "Deployment:apps/v1:myapp", "svc:testsvc0")
+	sourceBindingCreate(r, "my-binding0", "Deployment:apps/v1:myapp", "svc:testsvc0")
 
 	t.Log("delete source binding")
-	sourceBindingDelete(t, it, r, "my-binding0")
+	sourceBindingDelete(r, "my-binding0")
 
 	t.Log("update source binding")
-	sourceBindingCreate(t, it, r, "my-binding1", "Deployment:apps/v1:myapp", "svc:testsvc0")
-	serviceCreate(t, it, r, "testsvc1")
-	sourceBindingUpdate(t, it, r, "my-binding1", "Deployment:apps/v1:myapp", "svc:testsvc1")
+	sourceBindingCreate(r, "my-binding1", "Deployment:apps/v1:myapp", "svc:testsvc0")
+	serviceCreate(r, "testsvc1")
+	sourceBindingUpdate(r, "my-binding1", "Deployment:apps/v1:myapp", "svc:testsvc1")
 	jpSinkRefNameInSpec := "jsonpath={.spec.sink.ref.name}"
 	out, err := getResourceFieldsWithJSONPath(t, it, "sinkbindings.sources.knative.dev", "my-binding1", jpSinkRefNameInSpec)
 	assert.NilError(t, err)
 	assert.Equal(t, out, "testsvc1")
 }
 
-func sourceBindingCreate(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, bindingName string, subject string, sink string) {
-	out := it.Kn().Run("source", "binding", "create", bindingName, "--subject", subject, "--sink", sink)
+func sourceBindingCreate(r *test.KnRunResultCollector, bindingName string, subject string, sink string) {
+	out := r.KnTest().Kn().Run("source", "binding", "create", bindingName, "--subject", subject, "--sink", sink)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "Sink", "binding", bindingName, "created", "namespace", it.Kn().Namespace()))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "Sink", "binding", bindingName, "created", "namespace", r.KnTest().Kn().Namespace()))
 }
 
-func sourceBindingDelete(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, bindingName string) {
-	out := it.Kn().Run("source", "binding", "delete", bindingName)
+func sourceBindingDelete(r *test.KnRunResultCollector, bindingName string) {
+	out := r.KnTest().Kn().Run("source", "binding", "delete", bindingName)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "Sink", "binding", bindingName, "deleted", "namespace", it.Kn().Namespace()))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "Sink", "binding", bindingName, "deleted", "namespace", r.KnTest().Kn().Namespace()))
 }
 
-func sourceBindingUpdate(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, bindingName string, subject string, sink string) {
-	out := it.Kn().Run("source", "binding", "update", bindingName, "--subject", subject, "--sink", sink)
+func sourceBindingUpdate(r *test.KnRunResultCollector, bindingName string, subject string, sink string) {
+	out := r.KnTest().Kn().Run("source", "binding", "update", bindingName, "--subject", subject, "--sink", sink)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAll(out.Stdout, bindingName, "updated", "namespace", it.Kn().Namespace()))
+	assert.Check(r.T(), util.ContainsAll(out.Stdout, bindingName, "updated", "namespace", r.KnTest().Kn().Namespace()))
 }
diff --git a/test/e2e/source_list_test.go b/test/e2e/source_list_test.go
index 75f66961..7d82c62d 100644
--- a/test/e2e/source_list_test.go
+++ b/test/e2e/source_list_test.go
@@ -34,16 +34,16 @@ func TestSourceListTypes(t *testing.T) {
 		assert.NilError(t, it.Teardown())
 	}()
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
 	t.Log("List available source types")
-	output := sourceListTypes(t, it, r)
+	output := sourceListTypes(r)
 	assert.Check(t, util.ContainsAll(output, "TYPE", "NAME", "DESCRIPTION", "Ping", "ApiServer"))
 
 	t.Log("List available source types in YAML format")
 
-	output = sourceListTypes(t, it, r, "-oyaml")
+	output = sourceListTypes(r, "-oyaml")
 	assert.Check(t, util.ContainsAll(output, "apiextensions.k8s.io/v1beta1", "CustomResourceDefinition", "Ping", "ApiServer"))
 }
 
@@ -55,27 +55,27 @@ func TestSourceList(t *testing.T) {
 		assert.NilError(t, it.Teardown())
 	}()
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
 	t.Log("List sources empty case")
-	output := sourceList(t, it, r)
+	output := sourceList(r)
 	assert.Check(t, util.ContainsAll(output, "No", "sources", "found", "namespace"))
 	assert.Check(t, util.ContainsNone(output, "NAME", "TYPE", "RESOURCE", "SINK", "READY"))
 
 	// non empty list case is tested in test/e2e/source_apiserver_it.go where source setup is present
 }
 
-func sourceListTypes(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, args ...string) string {
+func sourceListTypes(r *test.KnRunResultCollector, args ...string) string {
 	cmd := append([]string{"source", "list-types"}, args...)
-	out := it.Kn().Run(cmd...)
+	out := r.KnTest().Kn().Run(cmd...)
 	r.AssertNoError(out)
 	return out.Stdout
 }
 
-func sourceList(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, args ...string) string {
+func sourceList(r *test.KnRunResultCollector, args ...string) string {
 	cmd := append([]string{"source", "list"}, args...)
-	out := it.Kn().Run(cmd...)
+	out := r.KnTest().Kn().Run(cmd...)
 	r.AssertNoError(out)
 	return out.Stdout
 }
diff --git a/test/e2e/tekton_test.go b/test/e2e/tekton_test.go
index c024e1ef..b2ac387b 100644
--- a/test/e2e/tekton_test.go
+++ b/test/e2e/tekton_test.go
@@ -73,7 +73,7 @@ func TestTektonPipeline(t *testing.T) {
 	err = waitForPipelineSuccess(kubectl)
 	assert.NilError(t, err)
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 
 	const serviceName = "hello"
 	out := it.Kn().Run("service", "describe", serviceName)
diff --git a/test/e2e/traffic_split_test.go b/test/e2e/traffic_split_test.go
index 0672caf8..ebc014dc 100644
--- a/test/e2e/traffic_split_test.go
+++ b/test/e2e/traffic_split_test.go
@@ -88,314 +88,314 @@ func TestTrafficSplit(t *testing.T) {
 	t.Run("50:50",
 		func(t *testing.T) {
 			t.Log("tag two revisions as v1 and v2 and give 50-50% share")
-			r := test.NewKnRunResultCollector(t)
+			r := test.NewKnRunResultCollector(t, it)
 			defer r.DumpIfFailed()
 
 			serviceName := test.GetNextServiceName(serviceBase)
-			serviceCreate(t, it, r, serviceName)
+			serviceCreate(r, serviceName)
 
 			rev1 := fmt.Sprintf("%s-rev-1", serviceName)
-			serviceUpdateWithOptions(t, it, r, serviceName, "--env", "TARGET=v1", "--revision-name", rev1)
+			serviceUpdateWithOptions(r, serviceName, "--env", "TARGET=v1", "--revision-name", rev1)
 
 			rev2 := fmt.Sprintf("%s-rev-2", serviceName)
-			serviceUpdateWithOptions(t, it, r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
+			serviceUpdateWithOptions(r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
 
 			tflags := []string{"--tag", fmt.Sprintf("%s=v1,%s=v2", rev1, rev2),
 				"--traffic", "v1=50,v2=50"}
-			serviceUpdateWithOptions(t, it, r, serviceName, tflags...)
+			serviceUpdateWithOptions(r, serviceName, tflags...)
 
 			// make ordered fields per tflags (tag, revision, percent, latest)
 			expectedTargets := []TargetFields{newTargetFields("v1", rev1, 50, false), newTargetFields("v2", rev2, 50, false)}
-			verifyTargets(t, it, r, serviceName, expectedTargets)
-			serviceDelete(t, it, r, serviceName)
+			verifyTargets(r, serviceName, expectedTargets)
+			serviceDelete(r, serviceName)
 		},
 	)
 	t.Run("20:80",
 		func(t *testing.T) {
 			t.Log("ramp/up down a revision to 20% adjusting other traffic to accommodate")
-			r := test.NewKnRunResultCollector(t)
+			r := test.NewKnRunResultCollector(t, it)
 			defer r.DumpIfFailed()
 
 			serviceName := test.GetNextServiceName(serviceBase)
-			serviceCreate(t, it, r, serviceName)
+			serviceCreate(r, serviceName)
 
 			rev1 := fmt.Sprintf("%s-rev-1", serviceName)
-			serviceUpdateWithOptions(t, it, r, serviceName, "--env", "TARGET=v1", "--revision-name", rev1)
+			serviceUpdateWithOptions(r, serviceName, "--env", "TARGET=v1", "--revision-name", rev1)
 
 			rev2 := fmt.Sprintf("%s-rev-2", serviceName)
-			serviceUpdateWithOptions(t, it, r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
+			serviceUpdateWithOptions(r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
 
-			serviceUpdateWithOptions(t, it, r, serviceName, "--traffic", fmt.Sprintf("%s=20,%s=80", rev1, rev2))
+			serviceUpdateWithOptions(r, serviceName, "--traffic", fmt.Sprintf("%s=20,%s=80", rev1, rev2))
 
 			expectedTargets := []TargetFields{newTargetFields("", rev1, 20, false), newTargetFields("", rev2, 80, false)}
-			verifyTargets(t, it, r, serviceName, expectedTargets)
-			serviceDelete(t, it, r, serviceName)
+			verifyTargets(r, serviceName, expectedTargets)
+			serviceDelete(r, serviceName)
 		},
 	)
 	t.Run("TagCandidate",
 		func(t *testing.T) {
 			t.Log("tag a revision as candidate, without otherwise changing any traffic split")
-			r := test.NewKnRunResultCollector(t)
+			r := test.NewKnRunResultCollector(t, it)
 			defer r.DumpIfFailed()
 
 			serviceName := test.GetNextServiceName(serviceBase)
 			rev1 := fmt.Sprintf("%s-rev-1", serviceName)
-			serviceCreateWithOptions(t, it, r, serviceName, "--revision-name", rev1)
+			serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
 
 			rev2 := fmt.Sprintf("%s-rev-2", serviceName)
-			serviceUpdateWithOptions(t, it, r, serviceName, "--env", "TARGET=v1", "--revision-name", rev2)
+			serviceUpdateWithOptions(r, serviceName, "--env", "TARGET=v1", "--revision-name", rev2)
 
 			// no traffic, append new target with tag in traffic block
-			serviceUpdateWithOptions(t, it, r, serviceName, "--tag", fmt.Sprintf("%s=%s", rev1, "candidate"))
+			serviceUpdateWithOptions(r, serviceName, "--tag", fmt.Sprintf("%s=%s", rev1, "candidate"))
 
 			expectedTargets := []TargetFields{newTargetFields("", rev2, 100, true), newTargetFields("candidate", rev1, 0, false)}
-			verifyTargets(t, it, r, serviceName, expectedTargets)
-			serviceDelete(t, it, r, serviceName)
+			verifyTargets(r, serviceName, expectedTargets)
+			serviceDelete(r, serviceName)
 		},
 	)
 	t.Run("TagCandidate:2:98",
 		func(t *testing.T) {
 			t.Log("tag a revision as candidate, set 2% traffic adjusting other traffic to accommodate")
-			r := test.NewKnRunResultCollector(t)
+			r := test.NewKnRunResultCollector(t, it)
 			defer r.DumpIfFailed()
 
 			serviceName := test.GetNextServiceName(serviceBase)
 			rev1 := fmt.Sprintf("%s-rev-1", serviceName)
-			serviceCreateWithOptions(t, it, r, serviceName, "--revision-name", rev1)
+			serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
 
 			rev2 := fmt.Sprintf("%s-rev-2", serviceName)
-			serviceUpdateWithOptions(t, it, r, serviceName, "--env", "TARGET=v1", "--revision-name", rev2)
+			serviceUpdateWithOptions(r, serviceName, "--env", "TARGET=v1", "--revision-name", rev2)
 
 			// traffic by tag name and use % at the end
-			serviceUpdateWithOptions(t, it, r, serviceName,
+			serviceUpdateWithOptions(r, serviceName,
 				"--tag", fmt.Sprintf("%s=%s", rev1, "candidate"),
 				"--traffic", "candidate=2%,@latest=98%")
 
 			expectedTargets := []TargetFields{newTargetFields("", rev2, 98, true), newTargetFields("candidate", rev1, 2, false)}
-			verifyTargets(t, it, r, serviceName, expectedTargets)
-			serviceDelete(t, it, r, serviceName)
+			verifyTargets(r, serviceName, expectedTargets)
+			serviceDelete(r, serviceName)
 		},
 	)
 	t.Run("TagCurrent",
 		func(t *testing.T) {
 			t.Log("update tag for a revision from candidate to current, tag current is present on another revision")
-			r := test.NewKnRunResultCollector(t)
+			r := test.NewKnRunResultCollector(t, it)
 			defer r.DumpIfFailed()
 
 			serviceName := test.GetNextServiceName(serviceBase)
 			// make available 3 revisions for service first
 			rev1 := fmt.Sprintf("%s-rev-1", serviceName)
-			serviceCreateWithOptions(t, it, r, serviceName, "--revision-name", rev1)
+			serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
 
 			rev2 := fmt.Sprintf("%s-rev-2", serviceName)
-			serviceUpdateWithOptions(t, it, r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
+			serviceUpdateWithOptions(r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
 
 			rev3 := fmt.Sprintf("%s-rev-3", serviceName)
-			serviceUpdateWithOptions(t, it, r, serviceName, "--env", "TARGET=v3", "--revision-name", rev3) //note that this gives 100% traffic to latest revision (rev3)
+			serviceUpdateWithOptions(r, serviceName, "--env", "TARGET=v3", "--revision-name", rev3) //note that this gives 100% traffic to latest revision (rev3)
 
 			// make existing state: tag current and candidate exist in traffic block
-			serviceUpdateWithOptions(t, it, r, serviceName, "--tag", fmt.Sprintf("%s=current,%s=candidate", rev1, rev2))
+			serviceUpdateWithOptions(r, serviceName, "--tag", fmt.Sprintf("%s=current,%s=candidate", rev1, rev2))
 
 			// desired state of tags: update tag of revision (rev2) from candidate to current (which is present on rev1)
 			//untag first to update
-			serviceUpdateWithOptions(t, it, r, serviceName,
+			serviceUpdateWithOptions(r, serviceName,
 				"--untag", "current,candidate",
 				"--tag", fmt.Sprintf("%s=current", rev2))
 
 			// there will be 2 targets in existing block 1. @latest, 2.for revision $rev2
 			// target for rev1 is removed as it had no traffic and we untagged it's tag current
 			expectedTargets := []TargetFields{newTargetFields("", rev3, 100, true), newTargetFields("current", rev2, 0, false)}
-			verifyTargets(t, it, r, serviceName, expectedTargets)
-			serviceDelete(t, it, r, serviceName)
+			verifyTargets(r, serviceName, expectedTargets)
+			serviceDelete(r, serviceName)
 		},
 	)
 	t.Run("TagStagingLatest",
 		func(t *testing.T) {
 			t.Log("update tag from testing to staging for @latest revision")
-			r := test.NewKnRunResultCollector(t)
+			r := test.NewKnRunResultCollector(t, it)
 			defer r.DumpIfFailed()
 
 			serviceName := test.GetNextServiceName(serviceBase)
 			rev1 := fmt.Sprintf("%s-rev-1", serviceName)
-			serviceCreateWithOptions(t, it, r, serviceName, "--revision-name", rev1)
+			serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
 
 			// make existing state: tag @latest as testing
-			serviceUpdateWithOptions(t, it, r, serviceName, "--tag", "@latest=testing")
+			serviceUpdateWithOptions(r, serviceName, "--tag", "@latest=testing")
 
 			// desired state: change tag from testing to staging
-			serviceUpdateWithOptions(t, it, r, serviceName, "--untag", "testing", "--tag", "@latest=staging")
+			serviceUpdateWithOptions(r, serviceName, "--untag", "testing", "--tag", "@latest=staging")
 
 			expectedTargets := []TargetFields{newTargetFields("staging", rev1, 100, true)}
-			verifyTargets(t, it, r, serviceName, expectedTargets)
-			serviceDelete(t, it, r, serviceName)
+			verifyTargets(r, serviceName, expectedTargets)
+			serviceDelete(r, serviceName)
 		},
 	)
 	t.Run("TagStagingNonLatest",
 		func(t *testing.T) {
 			t.Log("update tag from testing to staging for a revision (non @latest)")
-			r := test.NewKnRunResultCollector(t)
+			r := test.NewKnRunResultCollector(t, it)
 			defer r.DumpIfFailed()
 
 			serviceName := test.GetNextServiceName(serviceBase)
 			rev1 := fmt.Sprintf("%s-rev-1", serviceName)
-			serviceCreateWithOptions(t, it, r, serviceName, "--revision-name", rev1)
+			serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
 
 			rev2 := fmt.Sprintf("%s-rev-2", serviceName)
-			serviceUpdateWithOptions(t, it, r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
+			serviceUpdateWithOptions(r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
 
 			// make existing state: tag a revision as testing
-			serviceUpdateWithOptions(t, it, r, serviceName, "--tag", fmt.Sprintf("%s=testing", rev1))
+			serviceUpdateWithOptions(r, serviceName, "--tag", fmt.Sprintf("%s=testing", rev1))
 
 			// desired state: change tag from testing to staging
-			serviceUpdateWithOptions(t, it, r, serviceName, "--untag", "testing", "--tag", fmt.Sprintf("%s=staging", rev1))
+			serviceUpdateWithOptions(r, serviceName, "--untag", "testing", "--tag", fmt.Sprintf("%s=staging", rev1))
 
 			expectedTargets := []TargetFields{newTargetFields("", rev2, 100, true),
 				newTargetFields("staging", rev1, 0, false)}
-			verifyTargets(t, it, r, serviceName, expectedTargets)
-			serviceDelete(t, it, r, serviceName)
+			verifyTargets(r, serviceName, expectedTargets)
+			serviceDelete(r, serviceName)
 		},
 	)
 	// test reducing number of targets from traffic blockdd
 	t.Run("RemoveTag",
 		func(t *testing.T) {
 			t.Log("remove a revision with tag old from traffic block entirely")
-			r := test.NewKnRunResultCollector(t)
+			r := test.NewKnRunResultCollector(t, it)
 			defer r.DumpIfFailed()
 
 			serviceName := test.GetNextServiceName(serviceBase)
 			rev1 := fmt.Sprintf("%s-rev-1", serviceName)
-			serviceCreateWithOptions(t, it, r, serviceName, "--revision-name", rev1)
+			serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
 
 			rev2 := fmt.Sprintf("%s-rev-2", serviceName)
-			serviceUpdateWithOptions(t, it, r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
+			serviceUpdateWithOptions(r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
 
 			// existing state: traffic block having a revision with tag old and some traffic
-			serviceUpdateWithOptions(t, it, r, serviceName,
+			serviceUpdateWithOptions(r, serviceName,
 				"--tag", fmt.Sprintf("%s=old", rev1),
 				"--traffic", "old=2,@latest=98")
 
 			// desired state: remove revision with tag old
-			serviceUpdateWithOptions(t, it, r, serviceName, "--untag", "old", "--traffic", "@latest=100")
+			serviceUpdateWithOptions(r, serviceName, "--untag", "old", "--traffic", "@latest=100")
 
 			expectedTargets := []TargetFields{newTargetFields("", rev2, 100, true)}
-			verifyTargets(t, it, r, serviceName, expectedTargets)
-			serviceDelete(t, it, r, serviceName)
+			verifyTargets(r, serviceName, expectedTargets)
+			serviceDelete(r, serviceName)
 		},
 	)
 	t.Run("TagStable:50:50",
 		func(t *testing.T) {
 			t.Log("tag a revision as stable and current with 50-50% traffic")
-			r := test.NewKnRunResultCollector(t)
+			r := test.NewKnRunResultCollector(t, it)
 			defer r.DumpIfFailed()
 
 			serviceName := test.GetNextServiceName(serviceBase)
 			rev1 := fmt.Sprintf("%s-rev-1", serviceName)
-			serviceCreateWithOptions(t, it, r, serviceName, "--revision-name", rev1)
+			serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
 
 			// existing state: traffic block having two targets
-			serviceUpdateWithOptions(t, it, r, serviceName, "--env", "TARGET=v2")
+			serviceUpdateWithOptions(r, serviceName, "--env", "TARGET=v2")
 
 			// desired state: tag non-@latest revision with two tags and 50-50% traffic each
-			serviceUpdateWithOptions(t, it, r, serviceName,
+			serviceUpdateWithOptions(r, serviceName,
 				"--tag", fmt.Sprintf("%s=stable,%s=current", rev1, rev1),
 				"--traffic", "stable=50%,current=50%")
 
 			expectedTargets := []TargetFields{newTargetFields("stable", rev1, 50, false), newTargetFields("current", rev1, 50, false)}
-			verifyTargets(t, it, r, serviceName, expectedTargets)
-			serviceDelete(t, it, r, serviceName)
+			verifyTargets(r, serviceName, expectedTargets)
+			serviceDelete(r, serviceName)
 		},
 	)
 	t.Run("RevertToLatest",
 		func(t *testing.T) {
 			t.Log("revert all traffic to latest ready revision of service")
-			r := test.NewKnRunResultCollector(t)
+			r := test.NewKnRunResultCollector(t, it)
 			defer r.DumpIfFailed()
 
 			serviceName := test.GetNextServiceName(serviceBase)
 			rev1 := fmt.Sprintf("%s-rev-1", serviceName)
-			serviceCreateWithOptions(t, it, r, serviceName, "--revision-name", rev1)
+			serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
 
 			rev2 := fmt.Sprintf("%s-rev-2", serviceName)
-			serviceUpdateWithOptions(t, it, r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
+			serviceUpdateWithOptions(r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
 
 			// existing state: latest ready revision not getting any traffic
-			serviceUpdateWithOptions(t, it, r, serviceName, "--traffic", fmt.Sprintf("%s=100", rev1))
+			serviceUpdateWithOptions(r, serviceName, "--traffic", fmt.Sprintf("%s=100", rev1))
 
 			// desired state: revert traffic to latest ready revision
-			serviceUpdateWithOptions(t, it, r, serviceName, "--traffic", "@latest=100")
+			serviceUpdateWithOptions(r, serviceName, "--traffic", "@latest=100")
 
 			expectedTargets := []TargetFields{newTargetFields("", rev2, 100, true)}
-			verifyTargets(t, it, r, serviceName, expectedTargets)
-			serviceDelete(t, it, r, serviceName)
+			verifyTargets(r, serviceName, expectedTargets)
+			serviceDelete(r, serviceName)
 		},
 	)
 	t.Run("TagLatestAsCurrent",
 		func(t *testing.T) {
 			t.Log("tag latest ready revision of service as current")
-			r := test.NewKnRunResultCollector(t)
+			r := test.NewKnRunResultCollector(t, it)
 			defer r.DumpIfFailed()
 
 			serviceName := test.GetNextServiceName(serviceBase)
 			// existing state: latest revision has no tag
 			rev1 := fmt.Sprintf("%s-rev-1", serviceName)
-			serviceCreateWithOptions(t, it, r, serviceName, "--revision-name", rev1)
+			serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
 
 			// desired state: tag latest ready revision as 'current'
-			serviceUpdateWithOptions(t, it, r, serviceName, "--tag", "@latest=current")
+			serviceUpdateWithOptions(r, serviceName, "--tag", "@latest=current")
 
 			expectedTargets := []TargetFields{newTargetFields("current", rev1, 100, true)}
-			verifyTargets(t, it, r, serviceName, expectedTargets)
-			serviceDelete(t, it, r, serviceName)
+			verifyTargets(r, serviceName, expectedTargets)
+			serviceDelete(r, serviceName)
 		},
 	)
 	t.Run("UpdateTag:100:0",
 		func(t *testing.T) {
 			t.Log("update tag for a revision as testing and assign all the traffic to it")
-			r := test.NewKnRunResultCollector(t)
+			r := test.NewKnRunResultCollector(t, it)
 			defer r.DumpIfFailed()
 
 			serviceName := test.GetNextServiceName(serviceBase)
 			rev1 := fmt.Sprintf("%s-rev-1", serviceName)
-			serviceCreateWithOptions(t, it, r, serviceName, "--revision-name", rev1)
+			serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
 
 			rev2 := fmt.Sprintf("%s-rev-2", serviceName)
-			serviceUpdateWithOptions(t, it, r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
+			serviceUpdateWithOptions(r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
 
 			// existing state: two revision exists with traffic share and
 			// each revision has tag and traffic portions
-			serviceUpdateWithOptions(t, it, r, serviceName,
+			serviceUpdateWithOptions(r, serviceName,
 				"--tag", fmt.Sprintf("@latest=current,%s=candidate", rev1),
 				"--traffic", "current=90,candidate=10")
 
 			// desired state: update tag for rev1 as testing (from candidate) with 100% traffic
-			serviceUpdateWithOptions(t, it, r, serviceName,
+			serviceUpdateWithOptions(r, serviceName,
 				"--untag", "candidate", "--tag", fmt.Sprintf("%s=testing", rev1),
 				"--traffic", "testing=100")
 
 			expectedTargets := []TargetFields{newTargetFields("current", rev2, 0, true),
 				newTargetFields("testing", rev1, 100, false)}
-			verifyTargets(t, it, r, serviceName, expectedTargets)
-			serviceDelete(t, it, r, serviceName)
+			verifyTargets(r, serviceName, expectedTargets)
+			serviceDelete(r, serviceName)
 		},
 	)
 	t.Run("TagReplace",
 		func(t *testing.T) {
 			t.Log("replace latest tag of a revision with old and give latest to another revision")
-			r := test.NewKnRunResultCollector(t)
+			r := test.NewKnRunResultCollector(t, it)
 			defer r.DumpIfFailed()
 
 			serviceName := test.GetNextServiceName(serviceBase)
 			rev1 := fmt.Sprintf("%s-rev-1", serviceName)
-			serviceCreateWithOptions(t, it, r, serviceName, "--revision-name", rev1)
+			serviceCreateWithOptions(r, serviceName, "--revision-name", rev1)
 
 			rev2 := fmt.Sprintf("%s-rev-2", serviceName)
-			serviceUpdateWithOptions(t, it, r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
+			serviceUpdateWithOptions(r, serviceName, "--env", "TARGET=v2", "--revision-name", rev2)
 
 			// existing state: a revision exist with latest tag
-			serviceUpdateWithOptions(t, it, r, serviceName, "--tag", fmt.Sprintf("%s=latest", rev1))
+			serviceUpdateWithOptions(r, serviceName, "--tag", fmt.Sprintf("%s=latest", rev1))
 
 			// desired state of revision tags: rev1=old rev2=latest
-			serviceUpdateWithOptions(t, it, r, serviceName,
+			serviceUpdateWithOptions(r, serviceName,
 				"--untag", "latest",
 				"--tag", fmt.Sprintf("%s=old,%s=latest", rev1, rev2))
 
@@ -406,34 +406,34 @@ func TestTrafficSplit(t *testing.T) {
 				// In spec of traffic block (not status) either latestReadyRevision:true or revisionName can be given per target
 				newTargetFields("latest", rev2, 0, false)}
 
-			verifyTargets(t, it, r, serviceName, expectedTargets)
-			serviceDelete(t, it, r, serviceName)
+			verifyTargets(r, serviceName, expectedTargets)
+			serviceDelete(r, serviceName)
 		},
 	)
 }
 
-func verifyTargets(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string, expectedTargets []TargetFields) {
-	out := serviceDescribeWithJSONPath(t, it, r, serviceName, targetsJsonPath)
-	assert.Check(t, out != "")
+func verifyTargets(r *test.KnRunResultCollector, serviceName string, expectedTargets []TargetFields) {
+	out := serviceDescribeWithJSONPath(r, serviceName, targetsJsonPath)
+	assert.Check(r.T(), out != "")
 	actualTargets, err := splitTargets(out, targetsSeparator, len(expectedTargets))
-	assert.NilError(t, err)
-	formattedActualTargets := formatActualTargets(t, it, actualTargets)
-	assert.DeepEqual(t, expectedTargets, formattedActualTargets)
-	if t.Failed() {
-		r.AddDump("service", serviceName, it.Kn().Namespace())
+	assert.NilError(r.T(), err)
+	formattedActualTargets := formatActualTargets(r.T(), r.KnTest(), actualTargets)
+	assert.DeepEqual(r.T(), expectedTargets, formattedActualTargets)
+	if r.T().Failed() {
+		r.AddDump("service", serviceName, r.KnTest().Kn().Namespace())
 	}
 }
 
-func serviceDescribeWithJSONPath(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName, jsonpath string) string {
-	out := it.Kn().Run("service", "describe", serviceName, "-o", jsonpath)
+func serviceDescribeWithJSONPath(r *test.KnRunResultCollector, serviceName, jsonpath string) string {
+	out := r.KnTest().Kn().Run("service", "describe", serviceName, "-o", jsonpath)
 	r.AssertNoError(out)
 	return out.Stdout
 }
 
-func serviceUpdateWithOptions(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, serviceName string, options ...string) {
+func serviceUpdateWithOptions(r *test.KnRunResultCollector, serviceName string, options ...string) {
 	command := []string{"service", "update", serviceName}
 	command = append(command, options...)
-	out := it.Kn().Run(command...)
+	out := r.KnTest().Kn().Run(command...)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "Service", serviceName, "updating", "namespace", it.Kn().Namespace()))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "Service", serviceName, "updating", "namespace", r.KnTest().Kn().Namespace()))
 }
diff --git a/test/e2e/trigger_inject_broker_test.go b/test/e2e/trigger_inject_broker_test.go
index 46c319ee..83769738 100644
--- a/test/e2e/trigger_inject_broker_test.go
+++ b/test/e2e/trigger_inject_broker_test.go
@@ -34,20 +34,20 @@ func TestInjectBrokerTrigger(t *testing.T) {
 		assert.NilError(t, it.Teardown())
 	}()
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
 	assert.NilError(t, err)
 
-	serviceCreate(t, it, r, "sinksvc0")
-	serviceCreate(t, it, r, "sinksvc1")
+	serviceCreate(r, "sinksvc0")
+	serviceCreate(r, "sinksvc1")
 
 	t.Log("create triggers and list them")
-	triggerCreateWithInject(t, it, r, "trigger1", "sinksvc0", []string{"a=b"})
-	triggerCreateWithInject(t, it, r, "trigger2", "sinksvc1", []string{"type=knative.dev.bar", "source=ping"})
-	verifyTriggerList(t, it, r, "trigger1", "trigger2")
-	triggerDelete(t, it, r, "trigger1")
-	triggerDelete(t, it, r, "trigger2")
+	triggerCreateWithInject(r, "trigger1", "sinksvc0", []string{"a=b"})
+	triggerCreateWithInject(r, "trigger2", "sinksvc1", []string{"type=knative.dev.bar", "source=ping"})
+	verifyTriggerList(r, "trigger1", "trigger2")
+	triggerDelete(r, "trigger1")
+	triggerDelete(r, "trigger2")
 
 	t.Log("create trigger with error")
 	out := it.Kn().Run("trigger", "create", "errorTrigger", "--broker", "mybroker", "--inject-broker",
@@ -56,12 +56,12 @@ func TestInjectBrokerTrigger(t *testing.T) {
 	assert.Check(t, util.ContainsAllIgnoreCase(out.Stderr, "broker", "name", "'default'", "--inject-broker", "flag"))
 }
 
-func triggerCreateWithInject(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, name string, sinksvc string, filters []string) {
+func triggerCreateWithInject(r *test.KnRunResultCollector, name string, sinksvc string, filters []string) {
 	args := []string{"trigger", "create", name, "--broker", "default", "--inject-broker", "--sink", "svc:" + sinksvc}
 	for _, v := range filters {
 		args = append(args, "--filter", v)
 	}
-	out := it.Kn().Run(args...)
+	out := r.KnTest().Kn().Run(args...)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "Trigger", name, "created", "namespace", it.Kn().Namespace()))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "Trigger", name, "created", "namespace", r.KnTest().Kn().Namespace()))
 }
diff --git a/test/e2e/trigger_test.go b/test/e2e/trigger_test.go
index 5f1499da..ef8d310f 100644
--- a/test/e2e/trigger_test.go
+++ b/test/e2e/trigger_test.go
@@ -37,46 +37,46 @@ func TestBrokerTrigger(t *testing.T) {
 		assert.NilError(t, it.Teardown())
 	}()
 
-	r := test.NewKnRunResultCollector(t)
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
 	err = lableNamespaceForDefaultBroker(t, it)
 	assert.NilError(t, err)
 	defer unlableNamespaceForDefaultBroker(t, it)
 
-	serviceCreate(t, it, r, "sinksvc0")
-	serviceCreate(t, it, r, "sinksvc1")
+	serviceCreate(r, "sinksvc0")
+	serviceCreate(r, "sinksvc1")
 
 	t.Log("create triggers and list them")
-	triggerCreate(t, it, r, "trigger1", "sinksvc0", []string{"a=b"})
-	triggerCreate(t, it, r, "trigger2", "sinksvc1", []string{"type=knative.dev.bar", "source=ping"})
-	verifyTriggerList(t, it, r, "trigger1", "trigger2")
-	triggerDelete(t, it, r, "trigger1")
-	triggerDelete(t, it, r, "trigger2")
+	triggerCreate(r, "trigger1", "sinksvc0", []string{"a=b"})
+	triggerCreate(r, "trigger2", "sinksvc1", []string{"type=knative.dev.bar", "source=ping"})
+	verifyTriggerList(r, "trigger1", "trigger2")
+	triggerDelete(r, "trigger1")
+	triggerDelete(r, "trigger2")
 
 	t.Log("create a trigger and delete it")
-	triggerCreate(t, it, r, "deltrigger", "sinksvc0", []string{"a=b"})
-	triggerDelete(t, it, r, "deltrigger")
-	verifyTriggerNotfound(t, it, r, "deltrigger")
+	triggerCreate(r, "deltrigger", "sinksvc0", []string{"a=b"})
+	triggerDelete(r, "deltrigger")
+	verifyTriggerNotfound(r, "deltrigger")
 
 	t.Log("create a trigger with filters and remove them one by one")
-	triggerCreate(t, it, r, "filtertrigger", "sinksvc0", []string{"foo=bar", "source=ping"})
-	verifyTriggerDescribe(t, it, r, "filtertrigger", "default", "sinksvc0", []string{"foo", "bar", "source", "ping"})
-	triggerUpdate(t, it, r, "filtertrigger", "foo-", "sinksvc0")
-	verifyTriggerDescribe(t, it, r, "filtertrigger", "default", "sinksvc0", []string{"source", "ping"})
-	triggerUpdate(t, it, r, "filtertrigger", "source-", "sinksvc0")
-	verifyTriggerDescribe(t, it, r, "filtertrigger", "default", "sinksvc0", nil)
-	triggerDelete(t, it, r, "filtertrigger")
+	triggerCreate(r, "filtertrigger", "sinksvc0", []string{"foo=bar", "source=ping"})
+	verifyTriggerDescribe(r, "filtertrigger", "default", "sinksvc0", []string{"foo", "bar", "source", "ping"})
+	triggerUpdate(r, "filtertrigger", "foo-", "sinksvc0")
+	verifyTriggerDescribe(r, "filtertrigger", "default", "sinksvc0", []string{"source", "ping"})
+	triggerUpdate(r, "filtertrigger", "source-", "sinksvc0")
+	verifyTriggerDescribe(r, "filtertrigger", "default", "sinksvc0", nil)
+	triggerDelete(r, "filtertrigger")
 
 	t.Log("create a trigger, describe and update it")
-	triggerCreate(t, it, r, "updtrigger", "sinksvc0", []string{"a=b"})
-	verifyTriggerDescribe(t, it, r, "updtrigger", "default", "sinksvc0", []string{"a", "b"})
-	triggerUpdate(t, it, r, "updtrigger", "type=knative.dev.bar", "sinksvc1")
-	verifyTriggerDescribe(t, it, r, "updtrigger", "default", "sinksvc1", []string{"a", "b", "type", "knative.dev.bar"})
-	triggerDelete(t, it, r, "updtrigger")
+	triggerCreate(r, "updtrigger", "sinksvc0", []string{"a=b"})
+	verifyTriggerDescribe(r, "updtrigger", "default", "sinksvc0", []string{"a", "b"})
+	triggerUpdate(r, "updtrigger", "type=knative.dev.bar", "sinksvc1")
+	verifyTriggerDescribe(r, "updtrigger", "default", "sinksvc1", []string{"a", "b", "type", "knative.dev.bar"})
+	triggerDelete(r, "updtrigger")
 
 	t.Log("create trigger with error return")
-	triggerCreateMissingSink(t, it, r, "errtrigger", "notfound")
+	triggerCreateMissingSink(r, "errtrigger", "notfound")
 }
 
 // Private functions
@@ -105,55 +105,55 @@ func lableNamespaceForDefaultBroker(t *testing.T, it *test.KnTest) error {
 	})
 }
 
-func triggerCreate(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, name string, sinksvc string, filters []string) {
+func triggerCreate(r *test.KnRunResultCollector, name string, sinksvc string, filters []string) {
 	args := []string{"trigger", "create", name, "--broker", "default", "--sink", "svc:" + sinksvc}
 	if len(filters) > 0 {
 		for _, v := range filters {
 			args = append(args, "--filter", v)
 		}
 	}
-	out := it.Kn().Run(args...)
+	out := r.KnTest().Kn().Run(args...)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "Trigger", name, "created", "namespace", it.Kn().Namespace()))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "Trigger", name, "created", "namespace", r.KnTest().Kn().Namespace()))
 }
 
-func triggerCreateMissingSink(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, name string, sinksvc string) {
-	out := it.Kn().Run("trigger", "create", name, "--broker", "default", "--sink", "svc:"+sinksvc)
+func triggerCreateMissingSink(r *test.KnRunResultCollector, name string, sinksvc string) {
+	out := r.KnTest().Kn().Run("trigger", "create", name, "--broker", "default", "--sink", "svc:"+sinksvc)
 	r.AssertError(out)
-	assert.Check(t, util.ContainsAll(out.Stderr, "services.serving.knative.dev", "not found"))
+	assert.Check(r.T(), util.ContainsAll(out.Stderr, "services.serving.knative.dev", "not found"))
 }
 
-func triggerDelete(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, name string) {
-	out := it.Kn().Run("trigger", "delete", name)
+func triggerDelete(r *test.KnRunResultCollector, name string) {
+	out := r.KnTest().Kn().Run("trigger", "delete", name)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "Trigger", name, "deleted", "namespace", it.Kn().Namespace()))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "Trigger", name, "deleted", "namespace", r.KnTest().Kn().Namespace()))
 }
 
-func triggerUpdate(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, name string, filter string, sinksvc string) {
-	out := it.Kn().Run("trigger", "update", name, "--filter", filter, "--sink", "svc:"+sinksvc)
+func triggerUpdate(r *test.KnRunResultCollector, name string, filter string, sinksvc string) {
+	out := r.KnTest().Kn().Run("trigger", "update", name, "--filter", filter, "--sink", "svc:"+sinksvc)
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, "Trigger", name, "updated", "namespace", it.Kn().Namespace()))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "Trigger", name, "updated", "namespace", r.KnTest().Kn().Namespace()))
 }
 
-func verifyTriggerList(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, triggers ...string) {
-	out := it.Kn().Run("trigger", "list")
+func verifyTriggerList(r *test.KnRunResultCollector, triggers ...string) {
+	out := r.KnTest().Kn().Run("trigger", "list")
 	r.AssertNoError(out)
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, triggers...))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, triggers...))
 }
 
-func verifyTriggerDescribe(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, name string, broker string, sink string, filters []string) {
-	out := it.Kn().Run("trigger", "describe", name)
+func verifyTriggerDescribe(r *test.KnRunResultCollector, name string, broker string, sink string, filters []string) {
+	out := r.KnTest().Kn().Run("trigger", "describe", name)
 	r.AssertNoError(out)
 	if len(filters) > 0 {
-		assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, filters...))
+		assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, filters...))
 	} else {
-		assert.Check(t, util.ContainsNone(out.Stdout, "Filter"))
+		assert.Check(r.T(), util.ContainsNone(out.Stdout, "Filter"))
 	}
-	assert.Check(t, util.ContainsAllIgnoreCase(out.Stdout, name, broker, sink))
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, name, broker, sink))
 }
 
-func verifyTriggerNotfound(t *testing.T, it *test.KnTest, r *test.KnRunResultCollector, name string) {
-	out := it.Kn().Run("trigger", "describe", name)
+func verifyTriggerNotfound(r *test.KnRunResultCollector, name string) {
+	out := r.KnTest().Kn().Run("trigger", "describe", name)
 	r.AssertError(out)
-	assert.Check(t, util.ContainsAll(out.Stderr, name, "not found"))
+	assert.Check(r.T(), util.ContainsAll(out.Stderr, name, "not found"))
 }
diff --git a/test/e2e/version_test.go b/test/e2e/version_test.go
index adb8e2fd..84beedec 100644
--- a/test/e2e/version_test.go
+++ b/test/e2e/version_test.go
@@ -28,10 +28,16 @@ import (
 func TestVersion(t *testing.T) {
 	t.Parallel()
 
-	r := test.NewKnRunResultCollector(t)
+	it, err := test.NewKnTest()
+	assert.NilError(t, err)
+	defer func() {
+		assert.NilError(t, it.Teardown())
+	}()
+
+	r := test.NewKnRunResultCollector(t, it)
 	defer r.DumpIfFailed()
 
-	out := test.Kn{}.Run("version")
+	out := r.KnTest().Kn().RunNoNamespace("version")
 	r.AssertNoError(out)
 	assert.Check(t, util.ContainsAll(out.Stdout, "Version"))
 }
diff --git a/test/local-e2e-tests.sh b/test/local-e2e-tests.sh
index a52f094a..8f1f7fd2 100755
--- a/test/local-e2e-tests.sh
+++ b/test/local-e2e-tests.sh
@@ -15,6 +15,7 @@
 # limitations under the License.
 
 export PATH=$PWD:$PATH
+export GO111MODULE=on
 
 dir=$(dirname "${BASH_SOURCE[0]}")
 base=$(cd "$dir/.." && pwd)
@@ -23,4 +24,4 @@ base=$(cd "$dir/.." && pwd)
 export KN_E2E_NAMESPACE=kne2etests
 
 echo "🧪  Testing"
-go test ${base}/test/e2e/ -test.v -tags "e2e ${E2E_TAGS}" "$@"
+go test -mod=vendor ${base}/test/e2e/ -test.v -tags "e2e ${E2E_TAGS}" "$@"
diff --git a/vendor/knative.dev/test-infra/scripts/e2e-tests.sh b/vendor/knative.dev/test-infra/scripts/e2e-tests.sh
index a78920dc..917f5ebf 100644
--- a/vendor/knative.dev/test-infra/scripts/e2e-tests.sh
+++ b/vendor/knative.dev/test-infra/scripts/e2e-tests.sh
@@ -93,7 +93,7 @@ function dump_cluster_state() {
   echo "***    Start of information dump    ***"
   echo "***************************************"
 
-  local output="${ARTIFACTS}/k8s.dump.txt"
+  local output="${ARTIFACTS}/k8s.dump-$(basename ${E2E_SCRIPT}).txt"
   echo ">>> The dump is located at ${output}"
 
   for crd in $(kubectl api-resources --verbs=list -o name | sort); do
diff --git a/vendor/knative.dev/test-infra/scripts/library.sh b/vendor/knative.dev/test-infra/scripts/library.sh
index 6a71ed55..434deda2 100644
--- a/vendor/knative.dev/test-infra/scripts/library.sh
+++ b/vendor/knative.dev/test-infra/scripts/library.sh
@@ -487,9 +487,10 @@ function run_go_tool() {
     if [[ ${action} == "get" && $(pwd) == "${REPO_ROOT_DIR}" ]]; then
       local temp_dir="$(mktemp -d)"
       local install_failed=0
-      pushd "${temp_dir}"
+      # Swallow the output as we are returning the stdout in the end.
+      pushd "${temp_dir}" > /dev/null 2>&1
       go ${action} $1 || install_failed=1
-      popd
+      popd > /dev/null 2>&1
       (( install_failed )) && return ${install_failed}
     else
       go ${action} $1
diff --git a/vendor/knative.dev/test-infra/scripts/presubmit-tests.sh b/vendor/knative.dev/test-infra/scripts/presubmit-tests.sh
index 11b09a68..c01adcb5 100644
--- a/vendor/knative.dev/test-infra/scripts/presubmit-tests.sh
+++ b/vendor/knative.dev/test-infra/scripts/presubmit-tests.sh
@@ -28,7 +28,7 @@ readonly PRESUBMIT_TEST_FAIL_FAST=${PRESUBMIT_TEST_FAIL_FAST:-0}
 readonly NO_PRESUBMIT_FILES=(\.png \.gitignore \.gitattributes ^OWNERS ^OWNERS_ALIASES ^AUTHORS)
 
 # Flag if this is a presubmit run or not.
-[[ IS_PROW && -n "${PULL_PULL_SHA}" ]] && IS_PRESUBMIT=1 || IS_PRESUBMIT=0
+(( IS_PROW )) && [[ -n "${PULL_PULL_SHA}" ]] && IS_PRESUBMIT=1 || IS_PRESUBMIT=0
 readonly IS_PRESUBMIT
 
 # List of changed files on presubmit, LF separated.
@@ -177,11 +177,12 @@ function default_build_test_runner() {
     # Consider an error message everything that's not a package name.
     errors_go1="$(grep -v '^\(github\.com\|knative\.dev\)/' "${report}" | sort | uniq)"
   fi
-  # Get all build tags in go code (ignore /vendor)
+  # Get all build tags in go code (ignore /vendor and /hack)
   local tags="$(grep -r '// +build' . \
-      | grep -v '^./vendor/' | cut -f3 -d' ' | sort | uniq | tr '\n' ' ')"
+      | grep -v '^./vendor/' | grep -v '^./hack/' | cut -f3 -d' ' | sort | uniq | tr '\n' ' ')"
   local tagged_pkgs="$(grep -r '// +build' . \
-    | grep -v '^./vendor/' | grep ":// +build " | cut -f1 -d: | xargs dirname | sort | uniq | tr '\n' ' ')"
+    | grep -v '^./vendor/' | grep -v '^./hack/' | grep ":// +build " | cut -f1 -d: | xargs dirname \
+    | sort | uniq | tr '\n' ' ')"
   for pkg in ${tagged_pkgs}; do
     # `go test -c` lets us compile the tests but do not run them.
     if ! capture_output "${report}" go test -c -tags="${tags}" ${pkg} ; then
@@ -362,7 +363,7 @@ function main() {
 
   local failed=0
 
-  if [[ ${#TESTS_TO_RUN[@]} > 0 ]]; then
+  if [[ ${#TESTS_TO_RUN[@]} -gt 0 ]]; then
     if (( RUN_BUILD_TESTS || RUN_UNIT_TESTS || RUN_INTEGRATION_TESTS )); then
       abort "--run-test must be used alone"
     fi