Repository: kubernetes-sigs/kueue

Issue:
Flaky E2E Test: TopologyAwareScheduling when Creating a Job requesting TAS should admit a Job via TAS
<!-- Please use this template while reporting a bug and provide as much info as possible. Not doing so may result in your bug not being addressed in a timely manner. Thanks!

If the matter is security related, please disclose it privately via https://kubernetes.io/security/
-->

/kind flake


**What happened**:

End To End Suite: kindest/node:v1.32.3: [It] TopologyAwareScheduling when Creating a Job requesting TAS should admit a Job via TAS 

```
{Timed out after 45.001s.
The function passed to Eventually failed at /home/prow/go/src/sigs.k8s.io/kueue/test/e2e/singlecluster/tas_test.go:140 with:
Expected
    <[]v1.Condition | len:2, cap:2>: [
        {
            Type: "QuotaReserved",
            Status: "True",
            ObservedGeneration: 1,
            LastTransitionTime: {
                Time: 2025-04-17T09:09:04Z,
            },
            Reason: "QuotaReserved",
            Message: "Quota reserved in ClusterQueue cluster-queue",
        },
        {
            Type: "Admitted",
            Status: "True",
            ObservedGeneration: 1,
            LastTransitionTime: {
                Time: 2025-04-17T09:09:04Z,
            },
            Reason: "Admitted",
            Message: "The workload is admitted",
        },
    ]
to have condition type Finished and status True failed [FAILED] Timed out after 45.001s.
The function passed to Eventually failed at /home/prow/go/src/sigs.k8s.io/kueue/test/e2e/singlecluster/tas_test.go:140 with:
Expected
    <[]v1.Condition | len:2, cap:2>: [
        {
            Type: "QuotaReserved",
            Status: "True",
            ObservedGeneration: 1,
            LastTransitionTime: {
                Time: 2025-04-17T09:09:04Z,
            },
            Reason: "QuotaReserved",
            Message: "Quota reserved in ClusterQueue cluster-queue",
        },
        {
            Type: "Admitted",
            Status: "True",
            ObservedGeneration: 1,
            LastTransitionTime: {
                Time: 2025-04-17T09:09:04Z,
            },
            Reason: "Admitted",
            Message: "The workload is admitted",
        },
    ]
to have condition type Finished and status True
In [It] at: /home/prow/go/src/sigs.k8s.io/kueue/test/e2e/singlecluster/tas_test.go:141 @ 04/17/25 09:09:49.382

There were additional failures detected after the initial failure. These are visible in the timeline
}
```

**What you expected to happen**:

No errors.

**How to reproduce it (as minimally and precisely as possible)**:

https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_kueue/5031/pull-kueue-test-e2e-main-1-32/1912792918750400512

**Anything else we need to know?**:

**Environment**:
- Kubernetes version (use `kubectl version`):
- Kueue version (use `git describe --tags --dirty --always`):
- Cloud provider or hardware configuration:
- OS (e.g: `cat /etc/os-release`):
- Kernel (e.g. `uname -a`):
- Install tools:
- Others:

Hints from issue comments:
@k8s-triage-robot: The Kubernetes project currently lacks enough contributors to adequately respond to all issues.

This bot triages un-triaged issues according to the following rules:
- After 90d of inactivity, `lifecycle/stale` is applied
- After 30d of inactivity since `lifecycle/stale` was applied, `lifecycle/rotten` is applied
- After 30d of inactivity since `lifecycle/rotten` was applied, the issue is closed

You can:
- Mark this issue as fresh with `/remove-lifecycle stale`
- Close this issue with `/close`
- Offer to help out with [Issue Triage][1]

Please send feedback to sig-contributor-experience at [kubernetes/community](https://github.com/kubernetes/community).

/lifecycle stale

[1]: https://www.kubernetes.dev/docs/guide/issue-triage/@tenzen-y: /remove-lifecycle@mimowo: /close
We no longer have logs to investigate, and also there were multiple fixes to TAS since reported.
I suggest to reopen if this re-occurs.@k8s-ci-robot: @mimowo: Closing this issue.

<details>

In response to [this](https://github.com/kubernetes-sigs/kueue/issues/5034#issuecomment-3163104141):

>/close
>We no longer have logs to investigate, and also there were multiple fixes to TAS since reported.
>I suggest to reopen if this re-occurs.


Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes-sigs/prow](https://github.com/kubernetes-sigs/prow/issues/new?title=Prow%20issue:) repository.
</details>

Solution patch:
diff --git a/apis/config/v1beta1/defaults.go b/apis/config/v1beta1/defaults.go
index 89a3d4c4b..924bb6f28 100644
--- a/apis/config/v1beta1/defaults.go
+++ b/apis/config/v1beta1/defaults.go
@@ -160,7 +160,7 @@ func SetDefaults_Configuration(cfg *Configuration) {
 		}
 	}
 
-	if !features.Enabled((features.ManagedJobsNamespaceSelector)) {
+	if !features.Enabled(features.ManagedJobsNamespaceSelector) {
 		// Backwards compatibility: default podOptions.NamespaceSelector if ManagedJobsNamespaceSelector disabled
 		if cfg.Integrations.PodOptions == nil {
 			cfg.Integrations.PodOptions = &PodIntegrationOptions{}
diff --git a/pkg/scheduler/preemption/preemption.go b/pkg/scheduler/preemption/preemption.go
index 44f2593a3..a3f5f35c5 100644
--- a/pkg/scheduler/preemption/preemption.go
+++ b/pkg/scheduler/preemption/preemption.go
@@ -482,7 +482,7 @@ func (p *Preemptor) findCandidates(wl *kueue.Workload, cq *cache.ClusterQueueSna
 	wlPriority := priority.Priority(wl)
 
 	if cq.Preemption.WithinClusterQueue != kueue.PreemptionPolicyNever {
-		considerSamePrio := (cq.Preemption.WithinClusterQueue == kueue.PreemptionPolicyLowerOrNewerEqualPriority)
+		considerSamePrio := cq.Preemption.WithinClusterQueue == kueue.PreemptionPolicyLowerOrNewerEqualPriority
 		preemptorTS := p.workloadOrdering.GetQueueOrderTimestamp(wl)
 
 		for _, candidateWl := range cq.Workloads {



Test patch:
diff --git a/pkg/util/testingjobs/job/wrappers.go b/pkg/util/testingjobs/job/wrappers.go
index a93f5e5c3..2c2ebbe51 100644
--- a/pkg/util/testingjobs/job/wrappers.go
+++ b/pkg/util/testingjobs/job/wrappers.go
@@ -77,6 +77,16 @@ func (j *JobWrapper) BackoffLimit(limit int32) *JobWrapper {
 	return j
 }
 
+func (j *JobWrapper) BackoffLimitPerIndex(limit int32) *JobWrapper {
+	j.Spec.BackoffLimitPerIndex = ptr.To(limit)
+	return j
+}
+
+func (j *JobWrapper) CompletionMode(mode batchv1.CompletionMode) *JobWrapper {
+	j.Spec.CompletionMode = &mode
+	return j
+}
+
 func (j *JobWrapper) TerminationGracePeriod(seconds int64) *JobWrapper {
 	j.Spec.Template.Spec.TerminationGracePeriodSeconds = ptr.To(seconds)
 	return j
diff --git a/test/e2e/certmanager/suite_test.go b/test/e2e/certmanager/suite_test.go
index 4f8a5fc4e..e2513ad4a 100644
--- a/test/e2e/certmanager/suite_test.go
+++ b/test/e2e/certmanager/suite_test.go
@@ -60,7 +60,10 @@ var _ = ginkgo.BeforeSuite(func() {
 
 	waitForAvailableStart := time.Now()
 	util.WaitForKueueAvailability(ctx, k8sClient)
-	ginkgo.GinkgoLogr.Info("Kueue operator is available in the cluster", "waitingTime", time.Since(waitForAvailableStart))
+	ginkgo.GinkgoLogr.Info(
+		"Kueue and all required operators are available in the cluster",
+		"waitingTime", time.Since(waitForAvailableStart),
+	)
 	defaultKueueCfg = util.GetKueueConfiguration(ctx, k8sClient)
 })
 
diff --git a/test/e2e/customconfigs/managejobswithoutqueuename_test.go b/test/e2e/customconfigs/managejobswithoutqueuename_test.go
index 2fbce6133..ca8ad7206 100644
--- a/test/e2e/customconfigs/managejobswithoutqueuename_test.go
+++ b/test/e2e/customconfigs/managejobswithoutqueuename_test.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package queuename
+package customconfigse2e
 
 import (
 	"github.com/onsi/ginkgo/v2"
diff --git a/test/e2e/customconfigs/suite_test.go b/test/e2e/customconfigs/suite_test.go
index ed1fd2406..3dc72c2c0 100644
--- a/test/e2e/customconfigs/suite_test.go
+++ b/test/e2e/customconfigs/suite_test.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package queuename
+package customconfigse2e
 
 import (
 	"context"
@@ -25,6 +25,7 @@ import (
 
 	"github.com/onsi/ginkgo/v2"
 	"github.com/onsi/gomega"
+	"k8s.io/client-go/rest"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	"sigs.k8s.io/kueue/apis/config/v1beta1"
@@ -33,6 +34,8 @@ import (
 
 var (
 	k8sClient       client.WithWatch
+	cfg             *rest.Config
+	restClient      *rest.RESTClient
 	ctx             context.Context
 	defaultKueueCfg *v1beta1.Configuration
 )
@@ -51,14 +54,19 @@ func TestAPIs(t *testing.T) {
 var _ = ginkgo.BeforeSuite(func() {
 	util.SetupLogger()
 
-	k8sClient, _ = util.CreateClientUsingCluster("")
+	k8sClient, cfg = util.CreateClientUsingCluster("")
+	restClient = util.CreateRestClient(cfg)
 	ctx = ginkgo.GinkgoT().Context()
 
 	waitForAvailableStart := time.Now()
 	util.WaitForKueueAvailability(ctx, k8sClient)
 	util.WaitForJobSetAvailability(ctx, k8sClient)
 	util.WaitForAppWrapperAvailability(ctx, k8sClient)
-	ginkgo.GinkgoLogr.Info("Kueue, JobSet and AppWrapper operators are available in the cluster", "waitingTime", time.Since(waitForAvailableStart))
+	util.WaitForLeaderWorkerSetAvailability(ctx, k8sClient)
+	ginkgo.GinkgoLogr.Info(
+		"Kueue and all required operators are available in the cluster",
+		"waitingTime", time.Since(waitForAvailableStart),
+	)
 	defaultKueueCfg = util.GetKueueConfiguration(ctx, k8sClient)
 })
 
diff --git a/test/e2e/customconfigs/waitforpodsready_test.go b/test/e2e/customconfigs/waitforpodsready_test.go
new file mode 100644
index 000000000..ed76a853b
--- /dev/null
+++ b/test/e2e/customconfigs/waitforpodsready_test.go
@@ -0,0 +1,287 @@
+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package customconfigse2e
+
+import (
+	"github.com/onsi/ginkgo/v2"
+	"github.com/onsi/gomega"
+	batchv1 "k8s.io/api/batch/v1"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/utils/ptr"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	configapi "sigs.k8s.io/kueue/apis/config/v1beta1"
+	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+	workloadjob "sigs.k8s.io/kueue/pkg/controller/jobs/job"
+	"sigs.k8s.io/kueue/pkg/util/testing"
+	testingjob "sigs.k8s.io/kueue/pkg/util/testingjobs/job"
+	"sigs.k8s.io/kueue/pkg/workload"
+	"sigs.k8s.io/kueue/test/util"
+)
+
+var _ = ginkgo.Describe("WaitForPodsReady Job Controller E2E", func() {
+	var (
+		ns    *corev1.Namespace
+		rf    *kueue.ResourceFlavor
+		cq    *kueue.ClusterQueue
+		lq    *kueue.LocalQueue
+		job   *batchv1.Job
+		wl    kueue.Workload
+		wlKey types.NamespacedName
+	)
+
+	ginkgo.BeforeEach(func() {
+		ns = util.CreateNamespaceFromPrefixWithLog(ctx, k8sClient, "wfpr-")
+
+		rf = testing.MakeResourceFlavor("default").Obj()
+		gomega.Expect(k8sClient.Create(ctx, rf)).Should(gomega.Succeed())
+
+		cq = testing.MakeClusterQueue("cq").
+			ResourceGroup(*testing.MakeFlavorQuotas(rf.Name).Resource(corev1.ResourceCPU, "10").Obj()).
+			Obj()
+		gomega.Expect(k8sClient.Create(ctx, cq)).Should(gomega.Succeed())
+
+		lq = testing.MakeLocalQueue("lq", ns.Name).ClusterQueue(cq.Name).Obj()
+		gomega.Expect(k8sClient.Create(ctx, lq)).Should(gomega.Succeed())
+	})
+
+	ginkgo.AfterEach(func() {
+		gomega.Expect(util.DeleteNamespace(ctx, k8sClient, ns)).To(gomega.Succeed())
+		util.ExpectObjectToBeDeleted(ctx, k8sClient, cq, true)
+		util.ExpectObjectToBeDeleted(ctx, k8sClient, rf, true)
+	})
+
+	ginkgo.When("WaitForPodsReady has a tiny Timeout and no RecoveryTimeout", func() {
+		ginkgo.BeforeEach(func() {
+			updateKueueConfiguration(func(cfg *configapi.Configuration) {
+				cfg.WaitForPodsReady = &configapi.WaitForPodsReady{
+					Enable:          true,
+					BlockAdmission:  ptr.To(true),
+					Timeout:         &metav1.Duration{Duration: util.TinyTimeout},
+					RecoveryTimeout: nil,
+					RequeuingStrategy: &configapi.RequeuingStrategy{
+						Timestamp:          ptr.To(configapi.EvictionTimestamp),
+						BackoffBaseSeconds: ptr.To(int32(10)),
+						BackoffLimitCount:  ptr.To(int32(1)),
+					},
+				}
+			})
+		})
+
+		ginkgo.It("should evict and requeue workload when pods readiness timeout is surpassed", func() {
+			ginkgo.By("creating a suspended job so its pods never report Ready", func() {
+				job = testingjob.MakeJob("job-timeout", ns.Name).
+					Queue(lq.Name).
+					Request(corev1.ResourceCPU, "2").
+					Parallelism(1).
+					Obj()
+				gomega.Expect(k8sClient.Create(ctx, job)).Should(gomega.Succeed())
+			})
+
+			wlKey = types.NamespacedName{
+				Name:      workloadjob.GetWorkloadNameForJob(job.Name, job.UID),
+				Namespace: ns.Name,
+			}
+
+			ginkgo.By("waiting for the workload to be created and verifying it is not admitted", func() {
+				gomega.Eventually(func(g gomega.Gomega) {
+					g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
+
+					g.Expect(wl.Status.Admission).To(gomega.BeNil())
+				}, util.Timeout, util.Interval).Should(gomega.Succeed())
+			})
+
+			ginkgo.By("waiting for the workload to be evicted", func() {
+				gomega.Eventually(func(g gomega.Gomega) {
+					g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
+
+					g.Expect(
+						workload.HasConditionWithTypeAndReason(&wl, &metav1.Condition{
+							Type:   kueue.WorkloadPodsReady,
+							Status: metav1.ConditionFalse,
+							Reason: kueue.WorkloadWaitForStart,
+						}),
+					).To(gomega.BeTrue())
+
+					g.Expect(
+						workload.HasConditionWithTypeAndReason(&wl, &metav1.Condition{
+							Type:   kueue.WorkloadEvicted,
+							Status: metav1.ConditionTrue,
+							Reason: kueue.WorkloadEvictedByPodsReadyTimeout,
+						}),
+					).To(gomega.BeTrue())
+				}, util.Timeout, util.Interval).Should(gomega.Succeed())
+			})
+
+			ginkgo.By("verifying that the job is suspended", func() {
+				gomega.Eventually(func(g gomega.Gomega) {
+					g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(job), job)).Should(gomega.Succeed())
+					g.Expect(ptr.Deref(job.Spec.Suspend, false)).To(gomega.BeTrue())
+				}, util.Timeout, util.Interval).Should(gomega.Succeed())
+			})
+
+			ginkgo.By("verifying that the workload is requeued", func() {
+				gomega.Eventually(func(g gomega.Gomega) {
+					g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
+					g.Expect(wl.Status.RequeueState).ShouldNot(gomega.BeNil())
+					g.Expect(*wl.Status.RequeueState.Count).To(gomega.Equal(int32(1)))
+				}, util.Timeout, util.Interval).Should(gomega.Succeed())
+			})
+
+			ginkgo.By("verifying that the workload is deactivated after the second eviction", func() {
+				gomega.Eventually(func(g gomega.Gomega) {
+					g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
+					g.Expect(ptr.Deref(wl.Spec.Active, true)).Should(gomega.BeFalse())
+				}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
+			})
+		})
+	})
+
+	ginkgo.When("WaitForPodsReady has default Timeout and a tiny RecoveryTimeout", func() {
+		ginkgo.BeforeEach(func() {
+			updateKueueConfiguration(func(cfg *configapi.Configuration) {
+				cfg.WaitForPodsReady = &configapi.WaitForPodsReady{
+					Enable:          true,
+					BlockAdmission:  ptr.To(true),
+					RecoveryTimeout: &metav1.Duration{Duration: util.TinyTimeout},
+					RequeuingStrategy: &configapi.RequeuingStrategy{
+						Timestamp:          ptr.To(configapi.EvictionTimestamp),
+						BackoffBaseSeconds: ptr.To(int32(1)),
+						BackoffLimitCount:  ptr.To(int32(1)),
+					},
+				}
+			})
+		})
+
+		ginkgo.It("should evict and requeue workload when pod failure causes recovery timeout", func() {
+			ginkgo.By("creating a job", func() {
+				job = testingjob.MakeJob("job-recovery-timeout", ns.Name).
+					Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
+					Queue(lq.Name).
+					Request(corev1.ResourceCPU, "2").
+					Parallelism(1).
+					BackoffLimitPerIndex(2).
+					CompletionMode(batchv1.IndexedCompletion).
+					Completions(1).
+					Obj()
+
+				gomega.Expect(k8sClient.Create(ctx, job)).Should(gomega.Succeed())
+			})
+
+			wlKey = types.NamespacedName{
+				Name:      workloadjob.GetWorkloadNameForJob(job.Name, job.UID),
+				Namespace: ns.Name,
+			}
+
+			ginkgo.By("checking workload availability", func() {
+				gomega.Eventually(func(g gomega.Gomega) {
+					g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
+					g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrue(kueue.WorkloadPodsReady))
+				}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
+			})
+
+			ginkgo.By("simulating pod failure", func() {
+				util.WaitForActivePodsAndTerminate(ctx, k8sClient, restClient, cfg, ns.Name, 1, 1)
+			})
+
+			ginkgo.By("verifying that the workload is requeued", func() {
+				gomega.Eventually(func(g gomega.Gomega) {
+					g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
+
+					g.Expect(wl.Status.RequeueState).ShouldNot(gomega.BeNil())
+					g.Expect(*wl.Status.RequeueState.Count).To(gomega.Equal(int32(1)))
+
+					g.Expect(
+						workload.HasConditionWithTypeAndReason(&wl, &metav1.Condition{
+							Type:   kueue.WorkloadPodsReady,
+							Status: metav1.ConditionTrue,
+							Reason: kueue.WorkloadStarted,
+						}),
+					).To(gomega.BeTrue())
+
+					g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusFalse(kueue.WorkloadEvicted))
+
+					g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrue(kueue.WorkloadRequeued))
+				}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
+			})
+		})
+	})
+
+	ginkgo.When("WaitForPodsReady has default Timeout and a long RecoveryTimeout", func() {
+		ginkgo.BeforeEach(func() {
+			updateKueueConfiguration(func(cfg *configapi.Configuration) {
+				cfg.WaitForPodsReady = &configapi.WaitForPodsReady{
+					Enable:          true,
+					BlockAdmission:  ptr.To(true),
+					RecoveryTimeout: &metav1.Duration{Duration: util.LongTimeout},
+					RequeuingStrategy: &configapi.RequeuingStrategy{
+						Timestamp:          ptr.To(configapi.EvictionTimestamp),
+						BackoffBaseSeconds: ptr.To(int32(1)),
+						BackoffLimitCount:  ptr.To(int32(1)),
+					},
+				}
+			})
+		})
+
+		ginkgo.It("should continue running workload if pod recovers before recoveryTimeout", func() {
+			ginkgo.By("creating a job", func() {
+				job = testingjob.MakeJob("job-recovery-timeout", ns.Name).
+					Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
+					Queue(lq.Name).
+					Request(corev1.ResourceCPU, "2").
+					Parallelism(1).
+					BackoffLimitPerIndex(2).
+					CompletionMode(batchv1.IndexedCompletion).
+					Completions(1).
+					Obj()
+
+				gomega.Expect(k8sClient.Create(ctx, job)).Should(gomega.Succeed())
+			})
+
+			wlKey = types.NamespacedName{
+				Name:      workloadjob.GetWorkloadNameForJob(job.Name, job.UID),
+				Namespace: ns.Name,
+			}
+
+			ginkgo.By("checking workload availability", func() {
+				gomega.Eventually(func(g gomega.Gomega) {
+					g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
+					g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrue(kueue.WorkloadPodsReady))
+				}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
+			})
+
+			ginkgo.By("simulating pod failure", func() {
+				util.WaitForActivePodsAndTerminate(ctx, k8sClient, restClient, cfg, ns.Name, 1, 1)
+			})
+
+			ginkgo.By("verifying the pod is recovered before recoveryTimeout", func() {
+				gomega.Eventually(func(g gomega.Gomega) {
+					g.Expect(k8sClient.Get(ctx, wlKey, &wl)).Should(gomega.Succeed())
+					g.Expect(
+						workload.HasConditionWithTypeAndReason(&wl, &metav1.Condition{
+							Type:   kueue.WorkloadPodsReady,
+							Status: metav1.ConditionTrue,
+							Reason: kueue.WorkloadRecovered,
+						}),
+					).To(gomega.BeTrue())
+				}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
+			})
+		})
+	})
+})
diff --git a/test/e2e/multikueue/suite_test.go b/test/e2e/multikueue/suite_test.go
index 91a0dbd1c..4b73bb2b6 100644
--- a/test/e2e/multikueue/suite_test.go
+++ b/test/e2e/multikueue/suite_test.go
@@ -301,7 +301,10 @@ var _ = ginkgo.BeforeSuite(func() {
 	util.WaitForKubeRayOperatorAvailability(ctx, k8sWorker1Client)
 	util.WaitForKubeRayOperatorAvailability(ctx, k8sWorker2Client)
 
-	ginkgo.GinkgoLogr.Info("Kueue and all integration operators are available in all the clusters", "waitingTime", time.Since(waitForAvailableStart))
+	ginkgo.GinkgoLogr.Info(
+		"Kueue and all required operators are available in all the clusters",
+		"waitingTime", time.Since(waitForAvailableStart),
+	)
 	discoveryClient, err := discovery.NewDiscoveryClientForConfig(managerCfg)
 	gomega.Expect(err).NotTo(gomega.HaveOccurred())
 	managerK8SVersion, err = kubeversion.FetchServerVersion(discoveryClient)
diff --git a/test/e2e/singlecluster/suite_test.go b/test/e2e/singlecluster/suite_test.go
index 0beeb8b68..d905178e3 100644
--- a/test/e2e/singlecluster/suite_test.go
+++ b/test/e2e/singlecluster/suite_test.go
@@ -70,5 +70,8 @@ var _ = ginkgo.BeforeSuite(func() {
 	util.WaitForJobSetAvailability(ctx, k8sClient)
 	util.WaitForLeaderWorkerSetAvailability(ctx, k8sClient)
 	util.WaitForAppWrapperAvailability(ctx, k8sClient)
-	ginkgo.GinkgoLogr.Info("Kueue, JobSet, LeaderWorkerSet and AppWrapper operators are available in the cluster", "waitingTime", time.Since(waitForAvailableStart))
+	ginkgo.GinkgoLogr.Info(
+		"Kueue and all required operators are available in the cluster",
+		"waitingTime", time.Since(waitForAvailableStart),
+	)
 })
diff --git a/test/e2e/tas/suite_test.go b/test/e2e/tas/suite_test.go
index 9b9d1f4b6..d818f206e 100644
--- a/test/e2e/tas/suite_test.go
+++ b/test/e2e/tas/suite_test.go
@@ -64,7 +64,7 @@ var _ = ginkgo.BeforeSuite(func() {
 	util.WaitForLeaderWorkerSetAvailability(ctx, k8sClient)
 	util.WaitForKubeRayOperatorAvailability(ctx, k8sClient)
 	ginkgo.GinkgoLogr.Info(
-		"Kueue, JobSet, KubeFlow Training, KubeFlow MPI, AppWrapper, LeaderWorkerSet and KubeRay operators are available in the cluster",
+		"Kueue and all required operators are available in the cluster",
 		"waitingTime", time.Since(waitForAvailableStart),
 	)
 
diff --git a/test/util/e2e.go b/test/util/e2e.go
index c937d630e..c97350af7 100644
--- a/test/util/e2e.go
+++ b/test/util/e2e.go
@@ -322,6 +322,6 @@ func CreateNamespaceFromPrefixWithLog(ctx context.Context, k8sClient client.Clie
 
 func CreateNamespaceFromObjectWithLog(ctx context.Context, k8sClient client.Client, ns *corev1.Namespace) *corev1.Namespace {
 	MustCreate(ctx, k8sClient, ns)
-	ginkgo.GinkgoLogr.Info(fmt.Sprintf("Created namespace: %s", ns.Name))
+	ginkgo.GinkgoLogr.Info("Created namespace", "namespace", ns.Name)
 	return ns
 }