Repository: kubernetes-sigs/kueue

Issue:
[Flaky test] Should be stuck in termination until admitted workloads finished running
/kind flake

**What happened**:

failure on unrelated branch: https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_kueue/5276/pull-kueue-test-integration-baseline-main/1925940251549765632

**What you expected to happen**:

no failure

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

ci

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


```
{Timed out after 10.001s.
The function passed to Eventually failed at /home/prow/go/src/sigs.k8s.io/kueue/test/util/util.go:539 with:
local_queue_status with status=True
Expected
    <float64>: 1
to equal
    <float64>: 0 failed [FAILED] Timed out after 10.001s.
The function passed to Eventually failed at /home/prow/go/src/sigs.k8s.io/kueue/test/util/util.go:539 with:
local_queue_status with status=True
Expected
    <float64>: 1
to equal
    <float64>: 0
In [It] at: /home/prow/go/src/sigs.k8s.io/kueue/test/integration/singlecluster/controller/core/clusterqueue_controller_test.go:919 @ 05/23/25 15:48:12.255
}
```

Discussion:
@mykysha: /assign

Solution patch:
diff --git a/Makefile b/Makefile
index 99a343234..c7f2d881c 100644
--- a/Makefile
+++ b/Makefile
@@ -338,10 +338,9 @@ artifacts: clean-artifacts kustomize helm-chart-package prepare-manifests ## Gen
 
 .PHONY: prepare-release-branch
 prepare-release-branch: yq kustomize ## Prepare the release branch with the release version.
-	$(SED) -r 's/v[0-9]+\.[0-9]+\.[0-9]+/$(RELEASE_VERSION)/g' -i README.md -i site/hugo.toml
+	$(SED) -r 's/v[0-9]+\.[0-9]+\.[0-9]+/$(RELEASE_VERSION)/g' -i README.md -i site/hugo.toml -i cmd/kueueviz/INSTALL.md
 	$(SED) -r 's/chart_version = "[0-9]+\.[0-9]+\.[0-9]+/chart_version = "$(CHART_VERSION)/g' -i README.md -i site/hugo.toml
-	$(SED) -r 's/--version="v?[0-9]+\.[0-9]+\.[0-9]+/--version="$(CHART_VERSION)/g' -i charts/kueue/README.md
-	$(SED) -r 's/KUEUE_VERSION="[0-9]+\.[0-9]+\.[0-9]+/KUEUE_VERSION="$(CHART_VERSION)/g' -i cmd/kueueviz/INSTALL.md
+	$(SED) -r 's/--version="[0-9]+\.[0-9]+\.[0-9]+/--version="$(CHART_VERSION)/g' -i charts/kueue/README.md.gotmpl -i cmd/kueueviz/INSTALL.md
 	$(YQ) e '.appVersion = "$(RELEASE_VERSION)" | .version = "$(CHART_VERSION)"' -i charts/kueue/Chart.yaml
 	$(YQ) e '.controllerManager.manager.image.tag = "$(RELEASE_BRANCH)" | .kueueViz.backend.image.tag = "$(RELEASE_BRANCH)" | .kueueViz.frontend.image.tag = "$(RELEASE_BRANCH)"' -i charts/kueue/values.yaml
 
diff --git a/charts/kueue/README.md b/charts/kueue/README.md
index 3e3bc54e1..c110cf314 100644
--- a/charts/kueue/README.md
+++ b/charts/kueue/README.md
@@ -35,6 +35,9 @@ For more advanced parametrization of Kueue, we recommend using a local overrides
 
 ```yaml
 controllerManager:
+  featureGates:
+    - name: TopologyAwareScheduling
+      enabled: true
   replicas: 2
   manager:
     resources:
diff --git a/charts/kueue/README.md.gotmpl b/charts/kueue/README.md.gotmpl
index ee3a6f850..8ed6411a8 100644
--- a/charts/kueue/README.md.gotmpl
+++ b/charts/kueue/README.md.gotmpl
@@ -37,6 +37,9 @@ For more advanced parametrization of Kueue, we recommend using a local overrides
 
 ```yaml
 controllerManager:
+  featureGates:
+    - name: TopologyAwareScheduling
+      enabled: true
   replicas: 2
   manager:
     resources:
diff --git a/cmd/kueuectl/app/list/list_workload.go b/cmd/kueuectl/app/list/list_workload.go
index a46918e8d..322f0f9e8 100644
--- a/cmd/kueuectl/app/list/list_workload.go
+++ b/cmd/kueuectl/app/list/list_workload.go
@@ -430,10 +430,10 @@ func (o *WorkloadOptions) localQueues(ctx context.Context, list *v1beta1.Workloa
 	return localQueues, nil
 }
 
-func (o *WorkloadOptions) pendingWorkloads(ctx context.Context, list *v1beta1.WorkloadList, localQueues map[string]*v1beta1.LocalQueue) (map[workload.WorkloadReference]*visibility.PendingWorkload, error) {
+func (o *WorkloadOptions) pendingWorkloads(ctx context.Context, list *v1beta1.WorkloadList, localQueues map[string]*v1beta1.LocalQueue) (map[workload.Reference]*visibility.PendingWorkload, error) {
 	var err error
 
-	pendingWorkloads := make(map[workload.WorkloadReference]*visibility.PendingWorkload)
+	pendingWorkloads := make(map[workload.Reference]*visibility.PendingWorkload)
 	pendingWorkloadsSummaries := make(map[v1beta1.ClusterQueueReference]*visibility.PendingWorkloadsSummary)
 
 	for _, wl := range list.Items {
diff --git a/cmd/kueuectl/app/list/list_workload_printer.go b/cmd/kueuectl/app/list/list_workload_printer.go
index 0731f15f0..e2bd8dc8e 100644
--- a/cmd/kueuectl/app/list/list_workload_printer.go
+++ b/cmd/kueuectl/app/list/list_workload_printer.go
@@ -39,14 +39,14 @@ const crdTypeMaxLength = 20
 
 type listWorkloadResources struct {
 	localQueues      map[string]*v1beta1.LocalQueue
-	pendingWorkloads map[workload.WorkloadReference]*visibility.PendingWorkload
+	pendingWorkloads map[workload.Reference]*visibility.PendingWorkload
 	apiResourceLists map[string]*metav1.APIResourceList
 }
 
 func newListWorkloadResources() *listWorkloadResources {
 	return &listWorkloadResources{
 		localQueues:      make(map[string]*v1beta1.LocalQueue),
-		pendingWorkloads: make(map[workload.WorkloadReference]*visibility.PendingWorkload),
+		pendingWorkloads: make(map[workload.Reference]*visibility.PendingWorkload),
 		apiResourceLists: make(map[string]*metav1.APIResourceList),
 	}
 }
diff --git a/cmd/kueueviz/INSTALL.md b/cmd/kueueviz/INSTALL.md
index 0707b8d67..7f37c4bee 100644
--- a/cmd/kueueviz/INSTALL.md
+++ b/cmd/kueueviz/INSTALL.md
@@ -3,8 +3,7 @@
 KueueViz can be installed using `kubectl` with the following command:
 
 ```
-KUEUE_VERSION=0.11.1
-kubectl create -f https://github.com/kubernetes-sigs/kueue/releases/download/v$KUEUE_VERSION/kueueviz.yaml
+kubectl create -f https://github.com/kubernetes-sigs/kueue/releases/download/v0.12.2/kueueviz.yaml
 ```
 If you are using `kind` and that you don't have an `ingress` controller, you can use `port-forward` to 
 configure and run `KueueViz`:
@@ -23,9 +22,8 @@ KueueViz can be installed using helm using the following command and
 by ensuring that `enableKueueViz` is set to `true`:
 
 ```
-KUEUE_VERSION=0.11.1
 helm upgrade --install kueue oci://registry.k8s.io/kueue/charts/kueue \
-  --version=$KUEUE_VERSION
+  --version="0.12.2"
   --namespace kueue-system \
   --set enableKueueViz=true \
   --create-namespace
@@ -42,12 +40,11 @@ You need a kubernetes cluster running kueue.
 If you don't have a running cluster, you can create one using kind and install kueue using helm.
 
 ```
-KUEUE_VERSION=0.11.1
 kind create cluster
 kind get kubeconfig > kubeconfig
 export KUBECONFIG=$PWD/kubeconfig
 helm install kueue oci://us-central1-docker.pkg.dev/k8s-staging-images/charts/kueue \
-            --version="$KUEUE_VERSION" --create-namespace --namespace=kueue-system
+            --version="0.12.2" --create-namespace --namespace=kueue-system
 ```
 
 ## Build
diff --git a/pkg/cache/cache.go b/pkg/cache/cache.go
index 552504607..8d4ed39ed 100644
--- a/pkg/cache/cache.go
+++ b/pkg/cache/cache.go
@@ -104,7 +104,7 @@ type Cache struct {
 	podsReadyCond sync.Cond
 
 	client              client.Client
-	assumedWorkloads    map[workload.WorkloadReference]kueue.ClusterQueueReference
+	assumedWorkloads    map[workload.Reference]kueue.ClusterQueueReference
 	resourceFlavors     map[kueue.ResourceFlavorReference]*kueue.ResourceFlavor
 	podsReadyTracking   bool
 	admissionChecks     map[kueue.AdmissionCheckReference]AdmissionCheck
@@ -123,7 +123,7 @@ func New(client client.Client, opts ...Option) *Cache {
 	}
 	c := &Cache{
 		client:              client,
-		assumedWorkloads:    make(map[workload.WorkloadReference]kueue.ClusterQueueReference),
+		assumedWorkloads:    make(map[workload.Reference]kueue.ClusterQueueReference),
 		resourceFlavors:     make(map[kueue.ResourceFlavorReference]*kueue.ResourceFlavor),
 		admissionChecks:     make(map[kueue.AdmissionCheckReference]AdmissionCheck),
 		podsReadyTracking:   options.podsReadyTracking,
@@ -139,8 +139,8 @@ func New(client client.Client, opts ...Option) *Cache {
 func (c *Cache) newClusterQueue(log logr.Logger, cq *kueue.ClusterQueue) (*clusterQueue, error) {
 	cqImpl := &clusterQueue{
 		Name:                kueue.ClusterQueueReference(cq.Name),
-		Workloads:           make(map[workload.WorkloadReference]*workload.Info),
-		WorkloadsNotReady:   sets.New[workload.WorkloadReference](),
+		Workloads:           make(map[workload.Reference]*workload.Info),
+		WorkloadsNotReady:   sets.New[workload.Reference](),
 		localQueues:         make(map[queue.LocalQueueReference]*LocalQueue),
 		podsReadyTracking:   c.podsReadyTracking,
 		workloadInfoOptions: c.workloadInfoOptions,
@@ -148,7 +148,7 @@ func (c *Cache) newClusterQueue(log logr.Logger, cq *kueue.ClusterQueue) (*clust
 		resourceNode:        NewResourceNode(),
 		tasCache:            &c.tasCache,
 
-		workloadsNotAccountedForTAS: sets.New[workload.WorkloadReference](),
+		workloadsNotAccountedForTAS: sets.New[workload.Reference](),
 	}
 	c.hm.AddClusterQueue(cqImpl)
 	c.hm.UpdateClusterQueueEdge(kueue.ClusterQueueReference(cq.Name), cq.Spec.Cohort)
diff --git a/pkg/cache/clusterqueue.go b/pkg/cache/clusterqueue.go
index 12379cfed..eaf99d820 100644
--- a/pkg/cache/clusterqueue.go
+++ b/pkg/cache/clusterqueue.go
@@ -53,8 +53,8 @@ var (
 type clusterQueue struct {
 	Name              kueue.ClusterQueueReference
 	ResourceGroups    []ResourceGroup
-	Workloads         map[workload.WorkloadReference]*workload.Info
-	WorkloadsNotReady sets.Set[workload.WorkloadReference]
+	Workloads         map[workload.Reference]*workload.Info
+	WorkloadsNotReady sets.Set[workload.Reference]
 	NamespaceSelector labels.Selector
 	Preemption        kueue.ClusterQueuePreemption
 	FairWeight        resource.Quantity
@@ -88,7 +88,7 @@ type clusterQueue struct {
 
 	tasCache *tasCache
 
-	workloadsNotAccountedForTAS sets.Set[workload.WorkloadReference]
+	workloadsNotAccountedForTAS sets.Set[workload.Reference]
 }
 
 func (c *clusterQueue) GetName() kueue.ClusterQueueReference {
diff --git a/pkg/cache/clusterqueue_snapshot.go b/pkg/cache/clusterqueue_snapshot.go
index 5cff48d73..18f34fcca 100644
--- a/pkg/cache/clusterqueue_snapshot.go
+++ b/pkg/cache/clusterqueue_snapshot.go
@@ -37,8 +37,8 @@ import (
 type ClusterQueueSnapshot struct {
 	Name              kueue.ClusterQueueReference
 	ResourceGroups    []ResourceGroup
-	Workloads         map[workload.WorkloadReference]*workload.Info
-	WorkloadsNotReady sets.Set[workload.WorkloadReference]
+	Workloads         map[workload.Reference]*workload.Info
+	WorkloadsNotReady sets.Set[workload.Reference]
 	NamespaceSelector labels.Selector
 	Preemption        kueue.ClusterQueuePreemption
 	FairWeight        resource.Quantity
diff --git a/pkg/controller/jobframework/reconciler.go b/pkg/controller/jobframework/reconciler.go
index 8f30e55c5..a1432911e 100644
--- a/pkg/controller/jobframework/reconciler.go
+++ b/pkg/controller/jobframework/reconciler.go
@@ -666,16 +666,21 @@ func (r *JobReconciler) getWorkloadForObject(ctx context.Context, jobObj client.
 	if err := r.client.List(ctx, &wlList, client.InNamespace(jobObj.GetNamespace()), client.MatchingFields{indexer.OwnerReferenceUID: string(jobObj.GetUID())}); client.IgnoreNotFound(err) != nil {
 		return nil, err
 	}
-	if len(wlList.Items) > 0 {
-		// In theory the job can own multiple Workloads, we cannot do too much about it, maybe log it.
+
+	if len(wlList.Items) == 0 {
+		return nil, nil
+	}
+
+	// In theory the job can own multiple Workloads, we cannot do too much about it, maybe log it.
+	if len(wlList.Items) > 1 {
 		ctrl.LoggerFrom(ctx).V(2).Info(
-			"WARNING: The job has multiple associated Workloads.",
-			"job", jobObj.GetName(),
+			"WARNING: The job has multiple associated Workloads",
+			"job", klog.KObj(jobObj),
 			"workloads", klog.KObjSlice(wlList.Items),
 		)
-		return &wlList.Items[0], nil
 	}
-	return nil, nil
+
+	return &wlList.Items[0], nil
 }
 
 // FindAncestorJobManagedByKueue traverses controllerRefs to find the top-level ancestor Job managed by Kueue.
@@ -707,7 +712,7 @@ func FindAncestorJobManagedByKueue(ctx context.Context, c client.Client, jobObj
 		if seen.Has(currentObj.GetUID()) {
 			log.Error(ErrCyclicOwnership,
 				"Terminated search for Kueue-managed Job because of cyclic ownership",
-				"owner", currentObj,
+				"currentObj", currentObj,
 			)
 			return nil, ErrCyclicOwnership
 		}
@@ -715,12 +720,16 @@ func FindAncestorJobManagedByKueue(ctx context.Context, c client.Client, jobObj
 
 		owner := metav1.GetControllerOf(currentObj)
 		if owner == nil {
-			log.V(3).Info("stop walking up as the owner is not found", "owner", klog.KObj(currentObj))
+			log.V(3).Info("stop walking up as the owner is not found", "currentObj", klog.KObj(currentObj))
 			return topLevelJob, nil
 		}
 
 		if !manager.isKnownOwner(owner) {
-			log.V(3).Info("stop walking up as the owner is not known", "owner", klog.KObj(currentObj))
+			log.V(3).Info(
+				"stop walking up as the owner is not known",
+				"currentObj", klog.KObj(currentObj),
+				"owner", klog.KRef(jobObj.GetNamespace(), owner.Name),
+			)
 			return topLevelJob, nil
 		}
 		parentObj := getEmptyOwnerObject(owner)
diff --git a/pkg/queue/cluster_queue.go b/pkg/queue/cluster_queue.go
index a5cd1eb32..a02040636 100644
--- a/pkg/queue/cluster_queue.go
+++ b/pkg/queue/cluster_queue.go
@@ -56,12 +56,12 @@ var (
 type ClusterQueue struct {
 	hierarchy.ClusterQueue[*cohort]
 	name              kueue.ClusterQueueReference
-	heap              heap.Heap[workload.Info, workload.WorkloadReference]
+	heap              heap.Heap[workload.Info, workload.Reference]
 	namespaceSelector labels.Selector
 	active            bool
 
 	// inadmissibleWorkloads are workloads that have been tried at least once and couldn't be admitted.
-	inadmissibleWorkloads map[workload.WorkloadReference]*workload.Info
+	inadmissibleWorkloads map[workload.Reference]*workload.Info
 
 	// popCycle identifies the last call to Pop. It's incremented when calling Pop.
 	// popCycle and queueInadmissibleCycle are used to track when there is a requeuing
@@ -88,7 +88,7 @@ func (c *ClusterQueue) GetName() kueue.ClusterQueueReference {
 	return c.name
 }
 
-func workloadKey(i *workload.Info) workload.WorkloadReference {
+func workloadKey(i *workload.Info) workload.Reference {
 	return workload.Key(i.Obj)
 }
 
@@ -115,7 +115,7 @@ func newClusterQueueImpl(ctx context.Context, client client.Client, wo workload.
 	lessFunc := queueOrderingFunc(ctx, client, wo, fsResWeights, enableAdmissionFs)
 	return &ClusterQueue{
 		heap:                   *heap.New(workloadKey, lessFunc),
-		inadmissibleWorkloads:  make(map[workload.WorkloadReference]*workload.Info),
+		inadmissibleWorkloads:  make(map[workload.Reference]*workload.Info),
 		queueInadmissibleCycle: -1,
 		lessFunc:               lessFunc,
 		rwm:                    sync.RWMutex{},
@@ -274,7 +274,7 @@ func (c *ClusterQueue) requeueIfNotPresent(wInfo *workload.Info, immediate bool)
 	return true
 }
 
-func (c *ClusterQueue) forgetInflightByKey(key workload.WorkloadReference) {
+func (c *ClusterQueue) forgetInflightByKey(key workload.Reference) {
 	if c.inflight != nil && workload.Key(c.inflight.Obj) == key {
 		c.inflight = nil
 	}
@@ -290,7 +290,7 @@ func (c *ClusterQueue) QueueInadmissibleWorkloads(ctx context.Context, client cl
 		return false
 	}
 
-	inadmissibleWorkloads := make(map[workload.WorkloadReference]*workload.Info)
+	inadmissibleWorkloads := make(map[workload.Reference]*workload.Info)
 	moved := false
 	for key, wInfo := range c.inadmissibleWorkloads {
 		ns := corev1.Namespace{}
@@ -347,26 +347,26 @@ func (c *ClusterQueue) Pop() *workload.Info {
 // Dump produces a dump of the current workloads in the heap of
 // this ClusterQueue. It returns false if the queue is empty,
 // otherwise returns true.
-func (c *ClusterQueue) Dump() ([]workload.WorkloadReference, bool) {
+func (c *ClusterQueue) Dump() ([]workload.Reference, bool) {
 	c.rwm.RLock()
 	defer c.rwm.RUnlock()
 	if c.heap.Len() == 0 {
 		return nil, false
 	}
-	elements := make([]workload.WorkloadReference, c.heap.Len())
+	elements := make([]workload.Reference, c.heap.Len())
 	for i, info := range c.heap.List() {
 		elements[i] = workload.Key(info.Obj)
 	}
 	return elements, true
 }
 
-func (c *ClusterQueue) DumpInadmissible() ([]workload.WorkloadReference, bool) {
+func (c *ClusterQueue) DumpInadmissible() ([]workload.Reference, bool) {
 	c.rwm.RLock()
 	defer c.rwm.RUnlock()
 	if len(c.inadmissibleWorkloads) == 0 {
 		return nil, false
 	}
-	elements := make([]workload.WorkloadReference, 0, len(c.inadmissibleWorkloads))
+	elements := make([]workload.Reference, 0, len(c.inadmissibleWorkloads))
 	for _, info := range c.inadmissibleWorkloads {
 		elements = append(elements, workload.Key(info.Obj))
 	}
@@ -385,7 +385,7 @@ func (c *ClusterQueue) Snapshot() []*workload.Info {
 
 // Info returns workload.Info for the workload key.
 // Users of this method should not modify the returned object.
-func (c *ClusterQueue) Info(key workload.WorkloadReference) *workload.Info {
+func (c *ClusterQueue) Info(key workload.Reference) *workload.Info {
 	c.rwm.RLock()
 	defer c.rwm.RUnlock()
 	return c.heap.GetByKey(key)
diff --git a/pkg/queue/dumper.go b/pkg/queue/dumper.go
index 647003e64..bda4bf4e6 100644
--- a/pkg/queue/dumper.go
+++ b/pkg/queue/dumper.go
@@ -41,14 +41,14 @@ func (m *Manager) LogDump(log logr.Logger) {
 
 // Dump is a dump of the queues and it's elements (unordered).
 // Only use for testing purposes.
-func (m *Manager) Dump() map[kueue.ClusterQueueReference][]workload.WorkloadReference {
+func (m *Manager) Dump() map[kueue.ClusterQueueReference][]workload.Reference {
 	m.Lock()
 	defer m.Unlock()
 	clusterQueues := m.hm.ClusterQueues()
 	if len(clusterQueues) == 0 {
 		return nil
 	}
-	dump := make(map[kueue.ClusterQueueReference][]workload.WorkloadReference, len(clusterQueues))
+	dump := make(map[kueue.ClusterQueueReference][]workload.Reference, len(clusterQueues))
 	for key, cq := range clusterQueues {
 		if elements, ok := cq.Dump(); ok {
 			dump[key] = elements
@@ -62,14 +62,14 @@ func (m *Manager) Dump() map[kueue.ClusterQueueReference][]workload.WorkloadRefe
 
 // DumpInadmissible is a dump of the inadmissible workloads list.
 // Only use for testing purposes.
-func (m *Manager) DumpInadmissible() map[kueue.ClusterQueueReference][]workload.WorkloadReference {
+func (m *Manager) DumpInadmissible() map[kueue.ClusterQueueReference][]workload.Reference {
 	m.Lock()
 	defer m.Unlock()
 	clusterQueues := m.hm.ClusterQueues()
 	if len(clusterQueues) == 0 {
 		return nil
 	}
-	dump := make(map[kueue.ClusterQueueReference][]workload.WorkloadReference, len(clusterQueues))
+	dump := make(map[kueue.ClusterQueueReference][]workload.Reference, len(clusterQueues))
 	for key, cq := range clusterQueues {
 		if elements, ok := cq.DumpInadmissible(); ok {
 			dump[key] = elements
diff --git a/pkg/queue/local_queue.go b/pkg/queue/local_queue.go
index fecb283e6..315a62ee8 100644
--- a/pkg/queue/local_queue.go
+++ b/pkg/queue/local_queue.go
@@ -66,13 +66,13 @@ type LocalQueue struct {
 	Key          LocalQueueReference
 	ClusterQueue kueue.ClusterQueueReference
 
-	items map[workload.WorkloadReference]*workload.Info
+	items map[workload.Reference]*workload.Info
 }
 
 func newLocalQueue(q *kueue.LocalQueue) *LocalQueue {
 	qImpl := &LocalQueue{
 		Key:   Key(q),
-		items: make(map[workload.WorkloadReference]*workload.Info),
+		items: make(map[workload.Reference]*workload.Info),
 	}
 	qImpl.update(q)
 	return qImpl
diff --git a/pkg/queue/second_pass_queue.go b/pkg/queue/second_pass_queue.go
index abb2dc71d..c783a92eb 100644
--- a/pkg/queue/second_pass_queue.go
+++ b/pkg/queue/second_pass_queue.go
@@ -28,14 +28,14 @@ import (
 type secondPassQueue struct {
 	sync.RWMutex
 
-	prequeued sets.Set[workload.WorkloadReference]
-	queued    map[workload.WorkloadReference]*workload.Info
+	prequeued sets.Set[workload.Reference]
+	queued    map[workload.Reference]*workload.Info
 }
 
 func newSecondPassQueue() *secondPassQueue {
 	return &secondPassQueue{
-		prequeued: sets.New[workload.WorkloadReference](),
-		queued:    make(map[workload.WorkloadReference]*workload.Info),
+		prequeued: sets.New[workload.Reference](),
+		queued:    make(map[workload.Reference]*workload.Info),
 	}
 }
 
@@ -47,7 +47,7 @@ func (q *secondPassQueue) takeAllReady() []workload.Info {
 	for _, v := range q.queued {
 		result = append(result, *v)
 	}
-	q.queued = make(map[workload.WorkloadReference]*workload.Info)
+	q.queued = make(map[workload.Reference]*workload.Info)
 	return result
 }
 
@@ -71,7 +71,7 @@ func (q *secondPassQueue) queue(w *workload.Info) bool {
 	return enqueued
 }
 
-func (q *secondPassQueue) deleteByKey(key workload.WorkloadReference) {
+func (q *secondPassQueue) deleteByKey(key workload.Reference) {
 	q.Lock()
 	defer q.Unlock()
 
diff --git a/pkg/scheduler/fair_sharing_iterator.go b/pkg/scheduler/fair_sharing_iterator.go
index 56f257954..799e4f386 100644
--- a/pkg/scheduler/fair_sharing_iterator.go
+++ b/pkg/scheduler/fair_sharing_iterator.go
@@ -156,7 +156,7 @@ func runTournament(cohort *cache.CohortSnapshot, ec entryComparer, cqToEntry map
 
 type drsKey struct {
 	parentCohort kueue.CohortReference
-	workloadKey  workload.WorkloadReference
+	workloadKey  workload.Reference
 }
 
 type entryComparer struct {
diff --git a/pkg/scheduler/preemption/preempted_workloads.go b/pkg/scheduler/preemption/preempted_workloads.go
index 666fd163b..5d9ab2b8c 100644
--- a/pkg/scheduler/preemption/preempted_workloads.go
+++ b/pkg/scheduler/preemption/preempted_workloads.go
@@ -20,7 +20,7 @@ import (
 	"sigs.k8s.io/kueue/pkg/workload"
 )
 
-type PreemptedWorkloads map[workload.WorkloadReference]*workload.Info
+type PreemptedWorkloads map[workload.Reference]*workload.Info
 
 func (p PreemptedWorkloads) HasAny(newTargets []*Target) bool {
 	for _, target := range newTargets {
diff --git a/pkg/scheduler/scheduler.go b/pkg/scheduler/scheduler.go
index 5347c6936..c976494ef 100644
--- a/pkg/scheduler/scheduler.go
+++ b/pkg/scheduler/scheduler.go
@@ -341,9 +341,7 @@ type entry struct {
 }
 
 func (e *entry) assignmentUsage() workload.Usage {
-	return netUsage(e, func() resources.FlavorResourceQuantities {
-		return e.assignment.Usage.Quota
-	})
+	return netUsage(e, e.assignment.Usage.Quota)
 }
 
 // nominate returns the workloads with their requirements (resource flavors, borrowing) if
@@ -400,19 +398,17 @@ func fits(cq *cache.ClusterQueueSnapshot, usage *workload.Usage, preemptedWorklo
 
 // resourcesToReserve calculates how much of the available resources in cq/cohort assignment should be reserved.
 func resourcesToReserve(e *entry, cq *cache.ClusterQueueSnapshot) workload.Usage {
-	return netUsage(e, func() resources.FlavorResourceQuantities {
-		return quotaResourcesToReserve(e, cq)
-	})
+	return netUsage(e, quotaResourcesToReserve(e, cq))
 }
 
 // netUsage calculates the net usage for quota and TAS to reserve
-func netUsage(e *entry, netQuota func() resources.FlavorResourceQuantities) workload.Usage {
+func netUsage(e *entry, netQuota resources.FlavorResourceQuantities) workload.Usage {
 	result := workload.Usage{}
 	if features.Enabled(features.TopologyAwareScheduling) {
 		result.TAS = e.assignment.ComputeTASNetUsage(e.Obj.Status.Admission)
 	}
 	if !workload.HasQuotaReservation(e.Obj) {
-		result.Quota = netQuota()
+		result.Quota = netQuota
 	}
 	return result
 }
diff --git a/pkg/workload/workload.go b/pkg/workload/workload.go
index 164e38014..953dc2c90 100644
--- a/pkg/workload/workload.go
+++ b/pkg/workload/workload.go
@@ -69,11 +69,11 @@ var (
 	}
 )
 
-// WorkloadReference is the full reference to Workload formed as <namespace>/< kueue.WorkloadName >.
-type WorkloadReference string
+// Reference is the full reference to Workload formed as <namespace>/< kueue.WorkloadName >.
+type Reference string
 
-func NewWorkloadReference(namespace, name string) WorkloadReference {
-	return WorkloadReference(namespace + "/" + name)
+func NewReference(namespace, name string) Reference {
+	return Reference(namespace + "/" + name)
 }
 
 func Status(w *kueue.Workload) string {
@@ -393,8 +393,8 @@ func CanBePartiallyAdmitted(wl *kueue.Workload) bool {
 	return false
 }
 
-func Key(w *kueue.Workload) WorkloadReference {
-	return NewWorkloadReference(w.Namespace, w.Name)
+func Key(w *kueue.Workload) Reference {
+	return NewReference(w.Namespace, w.Name)
 }
 
 func reclaimableCounts(wl *kueue.Workload) map[kueue.PodSetReference]int32 {
diff --git a/site/content/en/docs/tasks/manage/productization/_index.md b/site/content/en/docs/tasks/manage/productization/_index.md
index cd7360658..7a363cbf3 100644
--- a/site/content/en/docs/tasks/manage/productization/_index.md
+++ b/site/content/en/docs/tasks/manage/productization/_index.md
@@ -1,7 +1,13 @@
 ---
 title: "Productionization of Kueue"
 weight: 1
-date: 2024-03-22
+date: 2025-06-17
 description: >
   As a _batch administrator_, you may want to configure the installation of Kueue.
----
\ No newline at end of file
+---
+
+{{% alert title="Note" color="primary" %}}
+For a streamlined installation and simplified upgrades, we recommend deploying Kueue using Helm.  
+You can customize the deployment with a local `values.yaml` file to fit your environment.  
+See the [Helm chart installation guide](/docs/installation/#install-by-helm) for full instructions.
+{{% /alert %}}
\ No newline at end of file


Test patch:
diff --git a/pkg/cache/cache_test.go b/pkg/cache/cache_test.go
index 102f96553..3d2c7de9c 100644
--- a/pkg/cache/cache_test.go
+++ b/pkg/cache/cache_test.go
@@ -460,7 +460,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					Status:     active,
 					Preemption: defaultPreemption,
 					FairWeight: oneQuantity,
-					Workloads: map[workload.WorkloadReference]*workload.Info{
+					Workloads: map[workload.Reference]*workload.Info{
 						"/one": {
 							Obj: utiltesting.MakeWorkload("one", "").
 								Request(corev1.ResourceCPU, "5").
@@ -895,7 +895,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 							{Flavor: "f1", Resource: corev1.ResourceCPU}: 2000,
 						},
 					},
-					Workloads: map[workload.WorkloadReference]*workload.Info{
+					Workloads: map[workload.Reference]*workload.Info{
 						"ns/reserving": {
 							ClusterQueue: "cq1",
 							TotalRequests: []workload.PodSetResources{
@@ -1195,7 +1195,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 		}).Obj())
 
 	type result struct {
-		Workloads     sets.Set[workload.WorkloadReference]
+		Workloads     sets.Set[workload.Reference]
 		UsedResources resources.FlavorResourceQuantities
 	}
 
@@ -1203,7 +1203,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 		name                 string
 		operation            func(log logr.Logger, cache *Cache) error
 		wantResults          map[kueue.ClusterQueueReference]result
-		wantAssumedWorkloads map[workload.WorkloadReference]kueue.ClusterQueueReference
+		wantAssumedWorkloads map[workload.Reference]kueue.ClusterQueueReference
 		wantError            string
 		wantLocalQueue       queue.LocalQueueReference
 	}{
@@ -1227,14 +1227,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c", "/d"),
+					Workloads: sets.New[workload.Reference]("/c", "/d"),
 				},
 			},
 		},
@@ -1252,14 +1252,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "failed to add workload",
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1276,14 +1276,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1301,14 +1301,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/b"),
+					Workloads: sets.New[workload.Reference]("/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 0,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      0,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/c"),
+					Workloads: sets.New[workload.Reference]("/a", "/c"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
@@ -1330,14 +1330,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "old ClusterQueue doesn't exist",
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1355,14 +1355,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "new ClusterQueue doesn't exist",
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1379,14 +1379,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c", "/d"),
+					Workloads: sets.New[workload.Reference]("/c", "/d"),
 				},
 			},
 		},
@@ -1400,14 +1400,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/b"),
+					Workloads: sets.New[workload.Reference]("/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 0,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      0,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1419,14 +1419,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/b"),
+					Workloads: sets.New[workload.Reference]("/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 0,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      0,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1439,14 +1439,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "cluster queue not found",
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1461,14 +1461,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "cluster queue not found",
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1482,14 +1482,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1515,21 +1515,21 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b", "/d"),
+					Workloads: sets.New[workload.Reference]("/a", "/b", "/d"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 20,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      30,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c", "/e"),
+					Workloads: sets.New[workload.Reference]("/c", "/e"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 			},
-			wantAssumedWorkloads: map[workload.WorkloadReference]kueue.ClusterQueueReference{
+			wantAssumedWorkloads: map[workload.Reference]kueue.ClusterQueueReference{
 				"/d": "one",
 				"/e": "two",
 			},
@@ -1548,17 +1548,17 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "cluster queue not found",
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
-			wantAssumedWorkloads: map[workload.WorkloadReference]kueue.ClusterQueueReference{},
+			wantAssumedWorkloads: map[workload.Reference]kueue.ClusterQueueReference{},
 		},
 		{
 			name: "forget",
@@ -1584,21 +1584,21 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c", "/e"),
+					Workloads: sets.New[workload.Reference]("/c", "/e"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 			},
-			wantAssumedWorkloads: map[workload.WorkloadReference]kueue.ClusterQueueReference{
+			wantAssumedWorkloads: map[workload.Reference]kueue.ClusterQueueReference{
 				"/e": "two",
 			},
 		},
@@ -1616,14 +1616,14 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			wantError: "the workload is not assumed",
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b"),
+					Workloads: sets.New[workload.Reference]("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c"),
+					Workloads: sets.New[workload.Reference]("/c"),
 				},
 			},
 		},
@@ -1654,21 +1654,21 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			},
 			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
-					Workloads: sets.New[workload.WorkloadReference]("/a", "/b", "/d"),
+					Workloads: sets.New[workload.Reference]("/a", "/b", "/d"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 20,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      30,
 					},
 				},
 				"two": {
-					Workloads: sets.New[workload.WorkloadReference]("/c", "/e"),
+					Workloads: sets.New[workload.Reference]("/c", "/e"),
 					UsedResources: resources.FlavorResourceQuantities{
 						{Flavor: "on-demand", Resource: corev1.ResourceCPU}: 10,
 						{Flavor: "spot", Resource: corev1.ResourceCPU}:      15,
 					},
 				},
 			},
-			wantAssumedWorkloads: map[workload.WorkloadReference]kueue.ClusterQueueReference{
+			wantAssumedWorkloads: map[workload.Reference]kueue.ClusterQueueReference{
 				"/e": "two",
 			},
 		},
@@ -1699,7 +1699,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				t.Errorf("Unexpected clusterQueues (-want,+got):\n%s", diff)
 			}
 			if step.wantAssumedWorkloads == nil {
-				step.wantAssumedWorkloads = map[workload.WorkloadReference]kueue.ClusterQueueReference{}
+				step.wantAssumedWorkloads = map[workload.Reference]kueue.ClusterQueueReference{}
 			}
 			if diff := cmp.Diff(step.wantAssumedWorkloads, cache.assumedWorkloads); diff != "" {
 				t.Errorf("Unexpected assumed workloads (-want,+got):\n%s", diff)
@@ -3204,13 +3204,13 @@ func TestIsAssumedOrAdmittedCheckWorkload(t *testing.T) {
 	tests := []struct {
 		name             string
 		clusterQueues    map[string]*clusterQueue
-		assumedWorkloads map[workload.WorkloadReference]kueue.ClusterQueueReference
+		assumedWorkloads map[workload.Reference]kueue.ClusterQueueReference
 		workload         workload.Info
 		expected         bool
 	}{
 		{
 			name:             "Workload Is Assumed and not Admitted",
-			assumedWorkloads: map[workload.WorkloadReference]kueue.ClusterQueueReference{"workload_namespace/workload_name": "test", "test2": "test2"},
+			assumedWorkloads: map[workload.Reference]kueue.ClusterQueueReference{"workload_namespace/workload_name": "test", "test2": "test2"},
 			workload: workload.Info{
 				ClusterQueue: "ClusterQueue1",
 				Obj: &kueue.Workload{
@@ -3227,7 +3227,7 @@ func TestIsAssumedOrAdmittedCheckWorkload(t *testing.T) {
 			clusterQueues: map[string]*clusterQueue{
 				"ClusterQueue1": {
 					Name: "ClusterQueue1",
-					Workloads: map[workload.WorkloadReference]*workload.Info{"workload_namespace/workload_name": {
+					Workloads: map[workload.Reference]*workload.Info{"workload_namespace/workload_name": {
 						Obj: &kueue.Workload{
 							ObjectMeta: metav1.ObjectMeta{
 								Name:      "workload_name",
@@ -3253,7 +3253,7 @@ func TestIsAssumedOrAdmittedCheckWorkload(t *testing.T) {
 			clusterQueues: map[string]*clusterQueue{
 				"ClusterQueue1": {
 					Name: "ClusterQueue1",
-					Workloads: map[workload.WorkloadReference]*workload.Info{"workload_namespace/workload_name": {
+					Workloads: map[workload.Reference]*workload.Info{"workload_namespace/workload_name": {
 						Obj: &kueue.Workload{
 							ObjectMeta: metav1.ObjectMeta{
 								Name:      "workload_name",
@@ -3262,7 +3262,7 @@ func TestIsAssumedOrAdmittedCheckWorkload(t *testing.T) {
 						},
 					}},
 				}},
-			assumedWorkloads: map[workload.WorkloadReference]kueue.ClusterQueueReference{"workload_namespace/workload_name": "test", "test2": "test2"},
+			assumedWorkloads: map[workload.Reference]kueue.ClusterQueueReference{"workload_namespace/workload_name": "test", "test2": "test2"},
 			workload: workload.Info{
 				ClusterQueue: "ClusterQueue1",
 				Obj: &kueue.Workload{
@@ -3279,7 +3279,7 @@ func TestIsAssumedOrAdmittedCheckWorkload(t *testing.T) {
 			clusterQueues: map[string]*clusterQueue{
 				"ClusterQueue1": {
 					Name: "ClusterQueue1",
-					Workloads: map[workload.WorkloadReference]*workload.Info{"workload_namespace2/workload_name2": {
+					Workloads: map[workload.Reference]*workload.Info{"workload_namespace2/workload_name2": {
 						Obj: &kueue.Workload{
 							ObjectMeta: metav1.ObjectMeta{
 								Name:      "workload_name2",
diff --git a/pkg/cache/snapshot_test.go b/pkg/cache/snapshot_test.go
index 16ea5fab5..637dcfee1 100644
--- a/pkg/cache/snapshot_test.go
+++ b/pkg/cache/snapshot_test.go
@@ -76,7 +76,7 @@ func TestSnapshot(t *testing.T) {
 							Status:                        active,
 							FlavorFungibility:             defaultFlavorFungibility,
 							AllocatableResourceGeneration: 1,
-							Workloads: map[workload.WorkloadReference]*workload.Info{
+							Workloads: map[workload.Reference]*workload.Info{
 								"/alpha": workload.NewInfo(
 									utiltesting.MakeWorkload("alpha", "").
 										ReserveQuota(&kueue.Admission{ClusterQueue: "a"}).Obj()),
@@ -90,7 +90,7 @@ func TestSnapshot(t *testing.T) {
 							Status:                        active,
 							FlavorFungibility:             defaultFlavorFungibility,
 							AllocatableResourceGeneration: 1,
-							Workloads: map[workload.WorkloadReference]*workload.Info{
+							Workloads: map[workload.Reference]*workload.Info{
 								"/beta": workload.NewInfo(
 									utiltesting.MakeWorkload("beta", "").
 										ReserveQuota(&kueue.Admission{ClusterQueue: "b"}).Obj()),
@@ -255,7 +255,7 @@ func TestSnapshot(t *testing.T) {
 									},
 								},
 								FlavorFungibility: defaultFlavorFungibility,
-								Workloads: map[workload.WorkloadReference]*workload.Info{
+								Workloads: map[workload.Reference]*workload.Info{
 									"/alpha": workload.NewInfo(utiltesting.MakeWorkload("alpha", "").
 										PodSets(*utiltesting.MakePodSet(kueue.DefaultPodSetName, 5).
 											Request(corev1.ResourceCPU, "2").Obj()).
@@ -299,7 +299,7 @@ func TestSnapshot(t *testing.T) {
 									},
 								},
 								FlavorFungibility: defaultFlavorFungibility,
-								Workloads: map[workload.WorkloadReference]*workload.Info{
+								Workloads: map[workload.Reference]*workload.Info{
 									"/beta": workload.NewInfo(utiltesting.MakeWorkload("beta", "").
 										PodSets(*utiltesting.MakePodSet(kueue.DefaultPodSetName, 5).
 											Request(corev1.ResourceCPU, "1").
@@ -380,7 +380,7 @@ func TestSnapshot(t *testing.T) {
 							NamespaceSelector:             labels.Everything(),
 							AllocatableResourceGeneration: 1,
 							Status:                        active,
-							Workloads:                     map[workload.WorkloadReference]*workload.Info{},
+							Workloads:                     map[workload.Reference]*workload.Info{},
 							FlavorFungibility:             defaultFlavorFungibility,
 							Preemption: kueue.ClusterQueuePreemption{
 								ReclaimWithinCohort: kueue.PreemptionPolicyAny,
@@ -405,7 +405,7 @@ func TestSnapshot(t *testing.T) {
 							NamespaceSelector:             labels.Everything(),
 							AllocatableResourceGeneration: 1,
 							Status:                        active,
-							Workloads:                     map[workload.WorkloadReference]*workload.Info{},
+							Workloads:                     map[workload.Reference]*workload.Info{},
 							FlavorFungibility:             defaultFlavorFungibility,
 							Preemption:                    defaultPreemption,
 							FairWeight:                    resource.MustParse("3"),
@@ -504,7 +504,7 @@ func TestSnapshot(t *testing.T) {
 								},
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
-								Workloads: map[workload.WorkloadReference]*workload.Info{
+								Workloads: map[workload.Reference]*workload.Info{
 									"/alpha": workload.NewInfo(utiltesting.MakeWorkload("alpha", "").
 										PodSets(*utiltesting.MakePodSet(kueue.DefaultPodSetName, 5).
 											Request(corev1.ResourceCPU, "2").Obj()).
@@ -659,7 +659,7 @@ func TestSnapshot(t *testing.T) {
 								},
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
-								Workloads: map[workload.WorkloadReference]*workload.Info{
+								Workloads: map[workload.Reference]*workload.Info{
 									"/alpha": workload.NewInfo(utiltesting.MakeWorkload("alpha", "").
 										PodSets(*utiltesting.MakePodSet(kueue.DefaultPodSetName, 5).
 											Request(corev1.ResourceCPU, "2").Obj()).
@@ -999,7 +999,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 			t.Fatalf("Couldn't add ClusterQueue to cache: %v", err)
 		}
 	}
-	wlInfos := make(map[workload.WorkloadReference]*workload.Info, len(workloads))
+	wlInfos := make(map[workload.Reference]*workload.Info, len(workloads))
 	for _, cq := range cqCache.hm.ClusterQueues() {
 		for _, wl := range cq.Workloads {
 			wlInfos[workload.Key(wl.Obj)] = wl
@@ -1011,17 +1011,17 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 	}
 	initialCohortResources := initialSnapshot.ClusterQueue("c1").Parent().ResourceNode.SubtreeQuota
 	cases := map[string]struct {
-		remove []workload.WorkloadReference
-		add    []workload.WorkloadReference
+		remove []workload.Reference
+		add    []workload.Reference
 		want   Snapshot
 	}{
 		"no-op remove add": {
-			remove: []workload.WorkloadReference{"/c1-cpu", "/c2-cpu-1"},
-			add:    []workload.WorkloadReference{"/c1-cpu", "/c2-cpu-1"},
+			remove: []workload.Reference{"/c1-cpu", "/c2-cpu-1"},
+			add:    []workload.Reference{"/c1-cpu", "/c2-cpu-1"},
 			want:   *initialSnapshot,
 		},
 		"remove all": {
-			remove: []workload.WorkloadReference{"/c1-cpu", "/c1-memory-alpha", "/c1-memory-beta", "/c2-cpu-1", "/c2-cpu-2"},
+			remove: []workload.Reference{"/c1-cpu", "/c1-memory-alpha", "/c1-memory-beta", "/c2-cpu-1", "/c2-cpu-2"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "cohort",
@@ -1042,7 +1042,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"c1": {
 								Name:              "c1",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("c1").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1061,7 +1061,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 							},
 							"c2": {
 								Name:                          "c2",
-								Workloads:                     make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:                     make(map[workload.Reference]*workload.Info),
 								ResourceGroups:                cqCache.hm.ClusterQueue("c2").ResourceGroups,
 								FlavorFungibility:             defaultFlavorFungibility,
 								FairWeight:                    oneQuantity,
@@ -1081,7 +1081,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 			}(),
 		},
 		"remove c1-cpu": {
-			remove: []workload.WorkloadReference{"/c1-cpu"},
+			remove: []workload.Reference{"/c1-cpu"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "cohort",
@@ -1102,7 +1102,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"c1": {
 								Name: "c1",
-								Workloads: map[workload.WorkloadReference]*workload.Info{
+								Workloads: map[workload.Reference]*workload.Info{
 									"/c1-memory-alpha": nil,
 									"/c1-memory-beta":  nil,
 								},
@@ -1124,7 +1124,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 							},
 							"c2": {
 								Name: "c2",
-								Workloads: map[workload.WorkloadReference]*workload.Info{
+								Workloads: map[workload.Reference]*workload.Info{
 									"/c2-cpu-1": nil,
 									"/c2-cpu-2": nil,
 								},
@@ -1147,7 +1147,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 			}(),
 		},
 		"remove c1-memory-alpha": {
-			remove: []workload.WorkloadReference{"/c1-memory-alpha"},
+			remove: []workload.Reference{"/c1-memory-alpha"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "cohort",
@@ -1168,7 +1168,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"c1": {
 								Name: "c1",
-								Workloads: map[workload.WorkloadReference]*workload.Info{
+								Workloads: map[workload.Reference]*workload.Info{
 									"/c1-memory-alpha": nil,
 									"/c1-memory-beta":  nil,
 								},
@@ -1190,7 +1190,7 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 							},
 							"c2": {
 								Name: "c2",
-								Workloads: map[workload.WorkloadReference]*workload.Info{
+								Workloads: map[workload.Reference]*workload.Info{
 									"/c2-cpu-1": nil,
 									"/c2-cpu-2": nil,
 								},
@@ -1293,7 +1293,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 			t.Fatalf("Couldn't add ClusterQueue to cache: %v", err)
 		}
 	}
-	wlInfos := make(map[workload.WorkloadReference]*workload.Info, len(workloads))
+	wlInfos := make(map[workload.Reference]*workload.Info, len(workloads))
 	for _, cq := range cqCache.hm.ClusterQueues() {
 		for _, wl := range cq.Workloads {
 			wlInfos[workload.Key(wl.Obj)] = wl
@@ -1305,17 +1305,17 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 	}
 	initialCohortResources := initialSnapshot.ClusterQueue("lend-a").Parent().ResourceNode.SubtreeQuota
 	cases := map[string]struct {
-		remove []workload.WorkloadReference
-		add    []workload.WorkloadReference
+		remove []workload.Reference
+		add    []workload.Reference
 		want   Snapshot
 	}{
 		"remove all then add all": {
-			remove: []workload.WorkloadReference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
-			add:    []workload.WorkloadReference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
+			remove: []workload.Reference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
+			add:    []workload.Reference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
 			want:   *initialSnapshot,
 		},
 		"remove all": {
-			remove: []workload.WorkloadReference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
+			remove: []workload.Reference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "lend",
@@ -1334,7 +1334,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-a").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1349,7 +1349,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 							},
 							"lend-b": {
 								Name:              "lend-b",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-b").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1368,7 +1368,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 			}(),
 		},
 		"remove workload, but still using quota over GuaranteedQuota": {
-			remove: []workload.WorkloadReference{"/lend-a-2"},
+			remove: []workload.Reference{"/lend-a-2"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "lend",
@@ -1387,7 +1387,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-a").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1402,7 +1402,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 							},
 							"lend-b": {
 								Name:                          "lend-b",
-								Workloads:                     make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:                     make(map[workload.Reference]*workload.Info),
 								ResourceGroups:                cqCache.hm.ClusterQueue("lend-b").ResourceGroups,
 								FlavorFungibility:             defaultFlavorFungibility,
 								FairWeight:                    oneQuantity,
@@ -1422,7 +1422,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 			}(),
 		},
 		"remove wokload, using same quota as GuaranteedQuota": {
-			remove: []workload.WorkloadReference{"/lend-a-1", "/lend-a-2"},
+			remove: []workload.Reference{"/lend-a-1", "/lend-a-2"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "lend",
@@ -1441,7 +1441,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-a").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1456,7 +1456,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 							},
 							"lend-b": {
 								Name:                          "lend-b",
-								Workloads:                     make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:                     make(map[workload.Reference]*workload.Info),
 								ResourceGroups:                cqCache.hm.ClusterQueue("lend-b").ResourceGroups,
 								FlavorFungibility:             defaultFlavorFungibility,
 								FairWeight:                    oneQuantity,
@@ -1476,7 +1476,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 			}(),
 		},
 		"remove workload, using less quota than GuaranteedQuota": {
-			remove: []workload.WorkloadReference{"/lend-a-2", "/lend-a-3"},
+			remove: []workload.Reference{"/lend-a-2", "/lend-a-3"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "lend",
@@ -1495,7 +1495,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-a").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1510,7 +1510,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 							},
 							"lend-b": {
 								Name:                          "lend-b",
-								Workloads:                     make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:                     make(map[workload.Reference]*workload.Info),
 								ResourceGroups:                cqCache.hm.ClusterQueue("lend-b").ResourceGroups,
 								FlavorFungibility:             defaultFlavorFungibility,
 								FairWeight:                    oneQuantity,
@@ -1530,8 +1530,8 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 			}(),
 		},
 		"remove all then add workload, using less quota than GuaranteedQuota": {
-			remove: []workload.WorkloadReference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
-			add:    []workload.WorkloadReference{"/lend-a-1"},
+			remove: []workload.Reference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
+			add:    []workload.Reference{"/lend-a-1"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "lend",
@@ -1550,7 +1550,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-a").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1565,7 +1565,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 							},
 							"lend-b": {
 								Name:                          "lend-b",
-								Workloads:                     make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:                     make(map[workload.Reference]*workload.Info),
 								ResourceGroups:                cqCache.hm.ClusterQueue("lend-b").ResourceGroups,
 								FlavorFungibility:             defaultFlavorFungibility,
 								FairWeight:                    oneQuantity,
@@ -1585,8 +1585,8 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 			}(),
 		},
 		"remove all then add workload, using same quota as GuaranteedQuota": {
-			remove: []workload.WorkloadReference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
-			add:    []workload.WorkloadReference{"/lend-a-3"},
+			remove: []workload.Reference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
+			add:    []workload.Reference{"/lend-a-3"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "lend",
@@ -1605,7 +1605,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-a").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1620,7 +1620,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 							},
 							"lend-b": {
 								Name:              "lend-b",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-b").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1639,8 +1639,8 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 			}(),
 		},
 		"remove all then add workload, using quota over GuaranteedQuota": {
-			remove: []workload.WorkloadReference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
-			add:    []workload.WorkloadReference{"/lend-a-2"},
+			remove: []workload.Reference{"/lend-a-1", "/lend-a-2", "/lend-a-3", "/lend-b-1"},
+			add:    []workload.Reference{"/lend-a-2"},
 			want: func() Snapshot {
 				cohort := &CohortSnapshot{
 					Name: "lend",
@@ -1659,7 +1659,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
-								Workloads:         make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:         make(map[workload.Reference]*workload.Info),
 								ResourceGroups:    cqCache.hm.ClusterQueue("lend-a").ResourceGroups,
 								FlavorFungibility: defaultFlavorFungibility,
 								FairWeight:        oneQuantity,
@@ -1674,7 +1674,7 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 							},
 							"lend-b": {
 								Name:                          "lend-b",
-								Workloads:                     make(map[workload.WorkloadReference]*workload.Info),
+								Workloads:                     make(map[workload.Reference]*workload.Info),
 								ResourceGroups:                cqCache.hm.ClusterQueue("lend-b").ResourceGroups,
 								FlavorFungibility:             defaultFlavorFungibility,
 								FairWeight:                    oneQuantity,
diff --git a/pkg/queue/cluster_queue_test.go b/pkg/queue/cluster_queue_test.go
index 55f51dca2..1051c38e6 100644
--- a/pkg/queue/cluster_queue_test.go
+++ b/pkg/queue/cluster_queue_test.go
@@ -69,7 +69,7 @@ func Test_PushOrUpdate(t *testing.T) {
 	cases := map[string]struct {
 		workload                  *utiltesting.WorkloadWrapper
 		wantWorkload              *workload.Info
-		wantInAdmissibleWorkloads map[workload.WorkloadReference]*workload.Info
+		wantInAdmissibleWorkloads map[workload.Reference]*workload.Info
 	}{
 		"workload doesn't have re-queue state": {
 			workload:     wlBase.Clone(),
@@ -87,7 +87,7 @@ func Test_PushOrUpdate(t *testing.T) {
 					Type:   kueue.WorkloadRequeued,
 					Status: metav1.ConditionFalse,
 				}),
-			wantInAdmissibleWorkloads: map[workload.WorkloadReference]*workload.Info{
+			wantInAdmissibleWorkloads: map[workload.Reference]*workload.Info{
 				"default/workload-1": workload.NewInfo(wlBase.Clone().
 					ResourceVersion("1").
 					RequeueState(ptr.To[int32](10), ptr.To(metav1.NewTime(minuteLater))).
@@ -114,7 +114,7 @@ func Test_PushOrUpdate(t *testing.T) {
 					Type:   kueue.WorkloadRequeued,
 					Status: metav1.ConditionFalse,
 				}),
-			wantInAdmissibleWorkloads: map[workload.WorkloadReference]*workload.Info{
+			wantInAdmissibleWorkloads: map[workload.Reference]*workload.Info{
 				"default/workload-1": workload.NewInfo(wlBase.Clone().
 					ResourceVersion("1").
 					Condition(metav1.Condition{
@@ -243,8 +243,8 @@ func Test_AddFromLocalQueue(t *testing.T) {
 	cq := newClusterQueueImpl(t.Context(), nil, defaultOrdering, testingclock.NewFakeClock(time.Now()), nil, false)
 	wl := utiltesting.MakeWorkload("workload-1", defaultNamespace).Obj()
 	queue := &LocalQueue{
-		items: map[workload.WorkloadReference]*workload.Info{
-			workload.WorkloadReference(wl.Name): workload.NewInfo(wl),
+		items: map[workload.Reference]*workload.Info{
+			workload.Reference(wl.Name): workload.NewInfo(wl),
 		},
 	}
 	cq.PushOrUpdate(workload.NewInfo(wl))
@@ -333,7 +333,7 @@ func TestClusterQueueImpl(t *testing.T) {
 		workloadsToUpdate                 []*kueue.Workload
 		workloadsToDelete                 []*kueue.Workload
 		queueInadmissibleWorkloads        bool
-		wantActiveWorkloads               []workload.WorkloadReference
+		wantActiveWorkloads               []workload.Reference
 		wantPending                       int
 		wantInadmissibleWorkloadsRequeued bool
 	}{
@@ -342,27 +342,27 @@ func TestClusterQueueImpl(t *testing.T) {
 			inadmissibleWorkloadsToRequeue: []*workload.Info{},
 			workloadsToUpdate:              []*kueue.Workload{updatedWorkloads[0]},
 			workloadsToDelete:              []*kueue.Workload{workloads[0]},
-			wantActiveWorkloads:            []workload.WorkloadReference{workload.Key(workloads[1])},
+			wantActiveWorkloads:            []workload.Reference{workload.Key(workloads[1])},
 			wantPending:                    2,
 		},
 		"re-queue inadmissible workload; workloads with requeueState can't re-queue": {
 			workloadsToAdd:                 []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToRequeue: []*workload.Info{workload.NewInfo(workloads[1]), workload.NewInfo(workloads[3])},
-			wantActiveWorkloads:            []workload.WorkloadReference{workload.Key(workloads[0])},
+			wantActiveWorkloads:            []workload.Reference{workload.Key(workloads[0])},
 			wantPending:                    3,
 		},
 		"re-queue admissible workload that was inadmissible": {
 			workloadsToAdd:                 []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToRequeue: []*workload.Info{workload.NewInfo(workloads[1]), workload.NewInfo(workloads[3])},
 			admissibleWorkloadsToRequeue:   []*workload.Info{workload.NewInfo(workloads[1]), workload.NewInfo(workloads[3])},
-			wantActiveWorkloads:            []workload.WorkloadReference{workload.Key(workloads[0]), workload.Key(workloads[1])},
+			wantActiveWorkloads:            []workload.Reference{workload.Key(workloads[0]), workload.Key(workloads[1])},
 			wantPending:                    3,
 		},
 		"re-queue inadmissible workload and flush": {
 			workloadsToAdd:                    []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToRequeue:    []*workload.Info{workload.NewInfo(workloads[1]), workload.NewInfo(workloads[3])},
 			queueInadmissibleWorkloads:        true,
-			wantActiveWorkloads:               []workload.WorkloadReference{workload.Key(workloads[0]), workload.Key(workloads[1])},
+			wantActiveWorkloads:               []workload.Reference{workload.Key(workloads[0]), workload.Key(workloads[1])},
 			wantPending:                       3,
 			wantInadmissibleWorkloadsRequeued: true,
 		},
@@ -370,14 +370,14 @@ func TestClusterQueueImpl(t *testing.T) {
 			workloadsToAdd:                 []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToRequeue: []*workload.Info{workload.NewInfo(workloads[2])},
 			queueInadmissibleWorkloads:     true,
-			wantActiveWorkloads:            []workload.WorkloadReference{workload.Key(workloads[0])},
+			wantActiveWorkloads:            []workload.Reference{workload.Key(workloads[0])},
 			wantPending:                    2,
 		},
 		"update inadmissible workload": {
 			workloadsToAdd:                 []*kueue.Workload{workloads[0]},
 			inadmissibleWorkloadsToRequeue: []*workload.Info{workload.NewInfo(workloads[1])},
 			workloadsToUpdate:              []*kueue.Workload{updatedWorkloads[1]},
-			wantActiveWorkloads:            []workload.WorkloadReference{workload.Key(workloads[0]), workload.Key(workloads[1])},
+			wantActiveWorkloads:            []workload.Reference{workload.Key(workloads[0]), workload.Key(workloads[1])},
 			wantPending:                    2,
 		},
 		"delete inadmissible workload": {
@@ -385,7 +385,7 @@ func TestClusterQueueImpl(t *testing.T) {
 			inadmissibleWorkloadsToRequeue: []*workload.Info{workload.NewInfo(workloads[1])},
 			workloadsToDelete:              []*kueue.Workload{workloads[1]},
 			queueInadmissibleWorkloads:     true,
-			wantActiveWorkloads:            []workload.WorkloadReference{workload.Key(workloads[0])},
+			wantActiveWorkloads:            []workload.Reference{workload.Key(workloads[0])},
 			wantPending:                    1,
 		},
 		"update inadmissible workload without changes": {
@@ -406,7 +406,7 @@ func TestClusterQueueImpl(t *testing.T) {
 					ReclaimablePods(kueue.ReclaimablePod{Name: kueue.DefaultPodSetName, Count: 1}).
 					Obj(),
 			},
-			wantActiveWorkloads: []workload.WorkloadReference{"/w"},
+			wantActiveWorkloads: []workload.Reference{"/w"},
 			wantPending:         1,
 		},
 	}
@@ -473,7 +473,7 @@ func TestQueueInadmissibleWorkloadsDuringScheduling(t *testing.T) {
 	ctx := t.Context()
 	cq.PushOrUpdate(workload.NewInfo(wl))
 
-	wantActiveWorkloads := []workload.WorkloadReference{workload.Key(wl)}
+	wantActiveWorkloads := []workload.Reference{workload.Key(wl)}
 
 	activeWorkloads, _ := cq.Dump()
 	if diff := cmp.Diff(wantActiveWorkloads, activeWorkloads, cmpDump...); diff != "" {
@@ -486,7 +486,7 @@ func TestQueueInadmissibleWorkloadsDuringScheduling(t *testing.T) {
 	cq.requeueIfNotPresent(head, false)
 
 	activeWorkloads, _ = cq.Dump()
-	wantActiveWorkloads = []workload.WorkloadReference{workload.Key(wl)}
+	wantActiveWorkloads = []workload.Reference{workload.Key(wl)}
 	if diff := cmp.Diff(wantActiveWorkloads, activeWorkloads, cmpDump...); diff != "" {
 		t.Errorf("Unexpected active workloads after scheduling with requeuing (-want,+got):\n%s", diff)
 	}
diff --git a/pkg/queue/manager_test.go b/pkg/queue/manager_test.go
index a582da955..c4d77e408 100644
--- a/pkg/queue/manager_test.go
+++ b/pkg/queue/manager_test.go
@@ -41,7 +41,7 @@ import (
 const headsTimeout = 3 * time.Second
 
 var cmpDump = cmp.Options{
-	cmpopts.SortSlices(func(a, b workload.WorkloadReference) bool { return a < b }),
+	cmpopts.SortSlices(func(a, b workload.Reference) bool { return a < b }),
 	cmpopts.IgnoreFields(metav1.Condition{}, "LastTransitionTime"),
 }
 
@@ -63,7 +63,7 @@ func TestAddLocalQueueOrphans(t *testing.T) {
 	}
 	qImpl := manager.localQueues[Key(q)]
 	workloadNames := workloadNamesFromLQ(qImpl)
-	if diff := cmp.Diff(sets.New[workload.WorkloadReference]("earth/a", "earth/c"), workloadNames); diff != "" {
+	if diff := cmp.Diff(sets.New[workload.Reference]("earth/a", "earth/c"), workloadNames); diff != "" {
 		t.Errorf("Unexpected items in queue foo (-want,+got):\n%s", diff)
 	}
 }
@@ -97,7 +97,7 @@ func TestAddClusterQueueOrphans(t *testing.T) {
 		}
 	}
 
-	wantActiveWorkloads := map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+	wantActiveWorkloads := map[kueue.ClusterQueueReference][]workload.Reference{
 		"cq": {"/a", "/b"},
 	}
 	if diff := cmp.Diff(wantActiveWorkloads, manager.Dump(), cmpDump...); diff != "" {
@@ -115,7 +115,7 @@ func TestAddClusterQueueOrphans(t *testing.T) {
 		t.Fatalf("Could not re-add ClusterQueue: %v", err)
 	}
 	workloads := popNamesFromCQ(manager.hm.ClusterQueue("cq"))
-	wantWorkloads := []workload.WorkloadReference{"/b", "/a"}
+	wantWorkloads := []workload.Reference{"/b", "/a"}
 	if diff := cmp.Diff(wantWorkloads, workloads); diff != "" {
 		t.Errorf("Workloads popped in the wrong order from clusterQueue:\n%s", diff)
 	}
@@ -163,7 +163,7 @@ func TestUpdateClusterQueue(t *testing.T) {
 
 	// Verify that all workloads are marked as inadmissible after creation.
 	inadmissibleWorkloads := manager.DumpInadmissible()
-	wantInadmissibleWorkloads := map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+	wantInadmissibleWorkloads := map[kueue.ClusterQueueReference][]workload.Reference{
 		"cq1": {"default/a"},
 		"cq2": {"default/b"},
 	}
@@ -171,7 +171,7 @@ func TestUpdateClusterQueue(t *testing.T) {
 		t.Errorf("Unexpected set of inadmissible workloads (-want +got):\n%s", diff)
 	}
 	activeWorkloads := manager.Dump()
-	if diff := cmp.Diff(map[kueue.ClusterQueueReference][]workload.WorkloadReference(nil), activeWorkloads); diff != "" {
+	if diff := cmp.Diff(map[kueue.ClusterQueueReference][]workload.Reference(nil), activeWorkloads); diff != "" {
 		t.Errorf("Unexpected active workloads (-want +got):\n%s", diff)
 	}
 
@@ -197,11 +197,11 @@ func TestUpdateClusterQueue(t *testing.T) {
 
 	// Verify that all workloads are active after the update.
 	inadmissibleWorkloads = manager.DumpInadmissible()
-	if diff := cmp.Diff(map[kueue.ClusterQueueReference][]workload.WorkloadReference(nil), inadmissibleWorkloads); diff != "" {
+	if diff := cmp.Diff(map[kueue.ClusterQueueReference][]workload.Reference(nil), inadmissibleWorkloads); diff != "" {
 		t.Errorf("Unexpected set of inadmissible workloads (-want +got):\n%s", diff)
 	}
 	activeWorkloads = manager.Dump()
-	wantActiveWorkloads := map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+	wantActiveWorkloads := map[kueue.ClusterQueueReference][]workload.Reference{
 		"cq1": {"default/a"},
 		"cq2": {"default/b"},
 	}
@@ -343,11 +343,11 @@ func TestUpdateLocalQueue(t *testing.T) {
 	}
 
 	// Verification.
-	workloadOrders := make(map[kueue.ClusterQueueReference][]workload.WorkloadReference)
+	workloadOrders := make(map[kueue.ClusterQueueReference][]workload.Reference)
 	for name, cq := range manager.hm.ClusterQueues() {
 		workloadOrders[name] = popNamesFromCQ(cq)
 	}
-	wantWorkloadOrders := map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+	wantWorkloadOrders := map[kueue.ClusterQueueReference][]workload.Reference{
 		"cq1": nil,
 		"cq2": {"/b", "/a"},
 	}
@@ -374,7 +374,7 @@ func TestDeleteLocalQueue(t *testing.T) {
 		t.Fatalf("Could not create LocalQueue: %v", err)
 	}
 
-	wantActiveWorkloads := map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+	wantActiveWorkloads := map[kueue.ClusterQueueReference][]workload.Reference{
 		"cq": {"/a"},
 	}
 	if diff := cmp.Diff(wantActiveWorkloads, manager.Dump(), cmpDump...); diff != "" {
@@ -655,8 +655,8 @@ func TestUpdateWorkload(t *testing.T) {
 		workloads        []*kueue.Workload
 		update           func(*kueue.Workload)
 		wantUpdated      bool
-		wantQueueOrder   map[kueue.ClusterQueueReference][]workload.WorkloadReference
-		wantQueueMembers map[LocalQueueReference]sets.Set[workload.WorkloadReference]
+		wantQueueOrder   map[kueue.ClusterQueueReference][]workload.Reference
+		wantQueueMembers map[LocalQueueReference]sets.Set[workload.Reference]
 		wantErr          error
 	}{
 		"in queue": {
@@ -674,11 +674,11 @@ func TestUpdateWorkload(t *testing.T) {
 				w.CreationTimestamp = metav1.NewTime(now.Add(time.Minute))
 			},
 			wantUpdated: true,
-			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq": {"/b", "/a"},
 			},
-			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.WorkloadReference]{
-				"/foo": sets.New[workload.WorkloadReference]("/a", "/b"),
+			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.Reference]{
+				"/foo": sets.New[workload.Reference]("/a", "/b"),
 			},
 		},
 		"between queues": {
@@ -696,12 +696,12 @@ func TestUpdateWorkload(t *testing.T) {
 				w.Spec.QueueName = "bar"
 			},
 			wantUpdated: true,
-			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq": {"/a"},
 			},
-			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.WorkloadReference]{
+			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.Reference]{
 				"/foo": nil,
-				"/bar": sets.New[workload.WorkloadReference]("/a"),
+				"/bar": sets.New[workload.Reference]("/a"),
 			},
 		},
 		"between cluster queues": {
@@ -720,13 +720,13 @@ func TestUpdateWorkload(t *testing.T) {
 				w.Spec.QueueName = "bar"
 			},
 			wantUpdated: true,
-			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq1": nil,
 				"cq2": {"/a"},
 			},
-			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.WorkloadReference]{
+			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.Reference]{
 				"/foo": nil,
-				"/bar": sets.New[workload.WorkloadReference]("/a"),
+				"/bar": sets.New[workload.Reference]("/a"),
 			},
 		},
 		"to non existent queue": {
@@ -742,10 +742,10 @@ func TestUpdateWorkload(t *testing.T) {
 			update: func(w *kueue.Workload) {
 				w.Spec.QueueName = "bar"
 			},
-			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq": nil,
 			},
-			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.WorkloadReference]{
+			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.Reference]{
 				"/foo": nil,
 			},
 			wantErr: ErrLocalQueueDoesNotExistOrInactive,
@@ -764,11 +764,11 @@ func TestUpdateWorkload(t *testing.T) {
 				w.Spec.QueueName = "foo"
 			},
 			wantUpdated: true,
-			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantQueueOrder: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq": {"/a"},
 			},
-			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.WorkloadReference]{
-				"/foo": sets.New[workload.WorkloadReference]("/a"),
+			wantQueueMembers: map[LocalQueueReference]sets.Set[workload.Reference]{
+				"/foo": sets.New[workload.Reference]("/a"),
 			},
 		},
 	}
@@ -814,14 +814,14 @@ func TestUpdateWorkload(t *testing.T) {
 					}
 				}
 			}
-			queueOrder := make(map[kueue.ClusterQueueReference][]workload.WorkloadReference)
+			queueOrder := make(map[kueue.ClusterQueueReference][]workload.Reference)
 			for name, cq := range manager.hm.ClusterQueues() {
 				queueOrder[name] = popNamesFromCQ(cq)
 			}
 			if diff := cmp.Diff(tc.wantQueueOrder, queueOrder); diff != "" {
 				t.Errorf("Elements popped in the wrong order from clusterQueues (-want,+got):\n%s", diff)
 			}
-			queueMembers := make(map[LocalQueueReference]sets.Set[workload.WorkloadReference])
+			queueMembers := make(map[LocalQueueReference]sets.Set[workload.Reference])
 			for name, q := range manager.localQueues {
 				queueMembers[name] = workloadNamesFromLQ(q)
 			}
@@ -1155,8 +1155,8 @@ func TestHeadsCancelled(t *testing.T) {
 
 // popNamesFromCQ pops all the workloads from the clusterQueue and returns
 // the keyed names in the order they are popped.
-func popNamesFromCQ(cq *ClusterQueue) []workload.WorkloadReference {
-	var names []workload.WorkloadReference
+func popNamesFromCQ(cq *ClusterQueue) []workload.Reference {
+	var names []workload.Reference
 	for w := cq.Pop(); w != nil; w = cq.Pop() {
 		names = append(names, workload.Key(w.Obj))
 	}
@@ -1164,8 +1164,8 @@ func popNamesFromCQ(cq *ClusterQueue) []workload.WorkloadReference {
 }
 
 // workloadNamesFromLQ returns all the names of the workloads in a localQueue.
-func workloadNamesFromLQ(q *LocalQueue) sets.Set[workload.WorkloadReference] {
-	names := sets.New[workload.WorkloadReference]()
+func workloadNamesFromLQ(q *LocalQueue) sets.Set[workload.Reference] {
+	names := sets.New[workload.Reference]()
 	for k := range q.items {
 		names.Insert(k)
 	}
@@ -1285,9 +1285,9 @@ func TestQueueSecondPassIfNeeded(t *testing.T) {
 
 	cases := map[string]struct {
 		workloads []*kueue.Workload
-		deleted   sets.Set[workload.WorkloadReference]
+		deleted   sets.Set[workload.Reference]
 		passTime  time.Duration
-		wantReady sets.Set[workload.WorkloadReference]
+		wantReady sets.Set[workload.Reference]
 	}{
 		"single queued workload checked immediately": {
 			workloads: []*kueue.Workload{baseWorkloadNeedingSecondPass.Obj()},
@@ -1314,7 +1314,7 @@ func TestQueueSecondPassIfNeeded(t *testing.T) {
 			},
 			deleted:   sets.New(workload.Key(baseWorkloadNeedingSecondPass.Obj())),
 			passTime:  time.Second,
-			wantReady: sets.New(workload.NewWorkloadReference("default", "second")),
+			wantReady: sets.New(workload.NewReference("default", "second")),
 		},
 	}
 	for name, tc := range cases {
@@ -1334,7 +1334,7 @@ func TestQueueSecondPassIfNeeded(t *testing.T) {
 				manager.secondPassQueue.deleteByKey(wl)
 			}
 			fakeClock.Step(tc.passTime)
-			gotReady := sets.New[workload.WorkloadReference]()
+			gotReady := sets.New[workload.Reference]()
 			for _, wlInfo := range manager.secondPassQueue.takeAllReady() {
 				gotReady.Insert(workload.Key(wlInfo.Obj))
 			}
diff --git a/pkg/scheduler/preemption/preemption_test.go b/pkg/scheduler/preemption/preemption_test.go
index ab60b57e8..ebdd1fc10 100644
--- a/pkg/scheduler/preemption/preemption_test.go
+++ b/pkg/scheduler/preemption/preemption_test.go
@@ -2787,7 +2787,7 @@ func TestFairPreemptions(t *testing.T) {
 	}
 }
 
-func targetKeyReason(key workload.WorkloadReference, reason string) string {
+func targetKeyReason(key workload.Reference, reason string) string {
 	return fmt.Sprintf("%s:%s", key, reason)
 }
 func TestCandidatesOrdering(t *testing.T) {
@@ -2827,11 +2827,11 @@ func TestCandidatesOrdering(t *testing.T) {
 	sort.Slice(candidates, func(i int, j int) bool {
 		return CandidatesOrdering(candidates[i], candidates[j], "self", now)
 	})
-	gotNames := make([]workload.WorkloadReference, len(candidates))
+	gotNames := make([]workload.Reference, len(candidates))
 	for i, c := range candidates {
 		gotNames[i] = workload.Key(c.Obj)
 	}
-	wantCandidates := []workload.WorkloadReference{"/evicted", "/other", "/low", "/current", "/old-a", "/old-b", "/high"}
+	wantCandidates := []workload.Reference{"/evicted", "/other", "/low", "/current", "/old-a", "/old-b", "/high"}
 	if diff := cmp.Diff(wantCandidates, gotNames); diff != "" {
 		t.Errorf("Sorted with wrong order (-want,+got):\n%s", diff)
 	}
diff --git a/pkg/scheduler/scheduler_test.go b/pkg/scheduler/scheduler_test.go
index 40427088a..24616ccb7 100644
--- a/pkg/scheduler/scheduler_test.go
+++ b/pkg/scheduler/scheduler_test.go
@@ -257,19 +257,19 @@ func TestSchedule(t *testing.T) {
 		cohorts []kueuealpha.Cohort
 
 		// wantAssignments is a summary of all the admissions in the cache after this cycle.
-		wantAssignments map[workload.WorkloadReference]kueue.Admission
+		wantAssignments map[workload.Reference]kueue.Admission
 		// wantScheduled is the subset of workloads that got scheduled/admitted in this cycle.
-		wantScheduled []workload.WorkloadReference
+		wantScheduled []workload.Reference
 		// workloadCmpOpts are the cmp options to compare workloads.
 		workloadCmpOpts cmp.Options
 		// wantWorkloads is the subset of workloads that got admitted in this cycle.
 		wantWorkloads []kueue.Workload
 		// wantLeft is the workload keys that are left in the queues after this cycle.
-		wantLeft map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantLeft map[kueue.ClusterQueueReference][]workload.Reference
 		// wantInadmissibleLeft is the workload keys that are left in the inadmissible state after this cycle.
-		wantInadmissibleLeft map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantInadmissibleLeft map[kueue.ClusterQueueReference][]workload.Reference
 		// wantPreempted is the keys of the workloads that get preempted in the scheduling cycle.
-		wantPreempted sets.Set[workload.WorkloadReference]
+		wantPreempted sets.Set[workload.Reference]
 		// wantEvents ignored if empty, the Message is ignored (it contains the duration)
 		wantEvents []utiltesting.EventRecord
 		// eventCmpOpts are the cmp options to compare recorded events.
@@ -291,7 +291,7 @@ func TestSchedule(t *testing.T) {
 					Generation(1).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/foo": {
 					ClusterQueue: "sales",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -308,7 +308,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"sales/foo"},
+			wantScheduled: []workload.Reference{"sales/foo"},
 			workloadCmpOpts: cmp.Options{
 				cmpopts.EquateEmpty(),
 				cmpopts.IgnoreFields(metav1.Condition{}, "LastTransitionTime"),
@@ -391,7 +391,7 @@ func TestSchedule(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/foo": {
 					ClusterQueue: "sales",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -408,7 +408,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"sales/foo"},
+			wantScheduled: []workload.Reference{"sales/foo"},
 			eventCmpOpts:  ignoreEventMessageCmpOpts,
 			wantEvents: []utiltesting.EventRecord{
 				{
@@ -428,7 +428,7 @@ func TestSchedule(t *testing.T) {
 					Obj(),
 			},
 			admissionError: errors.New("admission"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"sales": {"sales/foo"},
 			},
 		},
@@ -447,7 +447,7 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("sales", "one").Assignment(corev1.ResourceCPU, "default", "40000m").AssignmentPodCount(40).Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/assigned": {
 					ClusterQueue: "sales",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -464,7 +464,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"sales": {"sales/new"},
 			},
 		},
@@ -477,7 +477,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"eng-alpha": {"sales/new"},
 			},
 		},
@@ -496,7 +496,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/new": {
 					ClusterQueue: "sales",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -528,7 +528,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"sales/new", "eng-alpha/new"},
+			wantScheduled: []workload.Reference{"sales/new", "eng-alpha/new"},
 		},
 		"admit in same cohort with no borrowing": {
 			workloads: []kueue.Workload{
@@ -545,7 +545,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/new": {
 					ClusterQueue: "eng-alpha",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -577,7 +577,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/new", "eng-beta/new"},
+			wantScheduled: []workload.Reference{"eng-alpha/new", "eng-beta/new"},
 		},
 		"assign multiple resources and flavors": {
 			workloads: []kueue.Workload{
@@ -594,7 +594,7 @@ func TestSchedule(t *testing.T) {
 					).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-beta/new": {
 					ClusterQueue: "eng-beta",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -623,7 +623,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-beta/new"},
+			wantScheduled: []workload.Reference{"eng-beta/new"},
 		},
 		"cannot borrow if cohort was assigned and would result in overadmission": {
 			workloads: []kueue.Workload{
@@ -640,7 +640,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/new": {
 					ClusterQueue: "eng-alpha",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -657,8 +657,8 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/new"},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantScheduled: []workload.Reference{"eng-alpha/new"},
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"eng-beta": {"eng-beta/new"},
 			},
 		},
@@ -677,7 +677,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/new": {
 					ClusterQueue: "eng-alpha",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -709,7 +709,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/new", "eng-beta/new"},
+			wantScheduled: []workload.Reference{"eng-alpha/new", "eng-beta/new"},
 		},
 		"can borrow if needs reclaim from cohort in different flavor": {
 			workloads: []kueue.Workload{
@@ -730,15 +730,15 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("eng-beta").Assignment(corev1.ResourceCPU, "spot", "1000m").Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"eng-alpha": {"eng-alpha/can-reclaim"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-beta/user-spot":       *utiltesting.MakeAdmission("eng-beta").Assignment(corev1.ResourceCPU, "spot", "1000m").Obj(),
 				"eng-beta/user-on-demand":  *utiltesting.MakeAdmission("eng-beta").Assignment(corev1.ResourceCPU, "on-demand", "50000m").Obj(),
 				"eng-beta/needs-to-borrow": *utiltesting.MakeAdmission("eng-beta").Assignment(corev1.ResourceCPU, "on-demand", "1000m").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{
+			wantScheduled: []workload.Reference{
 				"eng-beta/needs-to-borrow",
 			},
 		},
@@ -753,10 +753,10 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "3").
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"lend/a": *utiltesting.MakeAdmission("lend-b").Assignment(corev1.ResourceCPU, "default", "2000m").Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"lend-b": {"lend/b"},
 			},
 		},
@@ -772,11 +772,11 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "3").
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"lend/a": *utiltesting.MakeAdmission("lend-b").Assignment(corev1.ResourceCPU, "default", "2000m").Obj(),
 				"lend/b": *utiltesting.MakeAdmission("lend-b").Assignment(corev1.ResourceCPU, "default", "3000m").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{
+			wantScheduled: []workload.Reference{
 				"lend/b",
 			},
 		},
@@ -805,12 +805,12 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "on-demand", "60000m").Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				// Preemptor is not admitted in this cycle.
 				"eng-beta": {"eng-beta/preemptor"},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/borrower", "eng-beta/low-2"),
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/borrower", "eng-beta/low-2"),
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/use-all-spot": *utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "spot", "100").Obj(),
 				"eng-beta/low-1":         *utiltesting.MakeAdmission("eng-beta").Assignment(corev1.ResourceCPU, "on-demand", "30").Obj(),
 				// Removal from cache for the preempted workloads is deferred until we receive Workload updates
@@ -859,15 +859,15 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "on-demand", "100").Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				// Preemptor is not admitted in this cycle.
 				"other-beta": {"eng-beta/preemptor"},
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/pending"},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/use-all"),
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/use-all"),
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				// Removal from cache for the preempted workloads is deferred until we receive Workload updates
 				"eng-alpha/use-all": *utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "on-demand", "100").Obj(),
 			},
@@ -879,7 +879,7 @@ func TestSchedule(t *testing.T) {
 					Request("example.com/gpu", "1").
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"eng-alpha": {"eng-alpha/new"},
 			},
 		},
@@ -898,7 +898,7 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("eng-beta", "one").Assignment(corev1.ResourceCPU, "on-demand", "45000m").AssignmentPodCount(45).Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/new": {
 					ClusterQueue: "eng-alpha",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -930,7 +930,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/new"},
+			wantScheduled: []workload.Reference{"eng-alpha/new"},
 		},
 		"workload should not fit in nonexistent clusterQueue": {
 			workloads: []kueue.Workload{
@@ -947,7 +947,7 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "1").
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"flavor-nonexistent-cq": {"sales/foo"},
 			},
 		},
@@ -1035,7 +1035,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-gamma/existing": *utiltesting.MakeAdmission("eng-gamma").
 					PodSets(
 						kueue.PodSetAssignment{
@@ -1062,8 +1062,8 @@ func TestSchedule(t *testing.T) {
 				"eng-beta/new":        *utiltesting.MakeAdmission("eng-beta", "one").Assignment(corev1.ResourceCPU, "on-demand", "50").AssignmentPodCount(50).Obj(),
 				"eng-alpha/new-alpha": *utiltesting.MakeAdmission("eng-alpha", "one").Assignment(corev1.ResourceCPU, "on-demand", "1").AssignmentPodCount(1).Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-beta/new", "eng-alpha/new-alpha"},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantScheduled: []workload.Reference{"eng-beta/new", "eng-alpha/new-alpha"},
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"eng-gamma": {"eng-gamma/new-gamma"},
 			},
 			wantSkippedPreemptions: map[string]int{
@@ -1082,7 +1082,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/new": {
 					ClusterQueue: "sales",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -1099,7 +1099,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"sales/new"},
+			wantScheduled: []workload.Reference{"sales/new"},
 		},
 		"partial admission single variable pod set, preempt first": {
 			workloads: []kueue.Workload{
@@ -1119,7 +1119,7 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("eng-beta", "one").Assignment("example.com/gpu", "model-a", "10").AssignmentPodCount(10).Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-beta/old": {
 					ClusterQueue: "eng-beta",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -1136,8 +1136,8 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-beta/old"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-beta/old"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"eng-beta": {"eng-beta/new"},
 			},
 		},
@@ -1159,7 +1159,7 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("eng-beta", "one").Assignment("example.com/gpu", "model-a", "10").AssignmentPodCount(10).Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-beta/old": {
 					ClusterQueue: "eng-beta",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -1176,8 +1176,8 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-beta/old"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-beta/old"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"eng-beta": {"eng-beta/new"},
 			},
 		},
@@ -1200,7 +1200,7 @@ func TestSchedule(t *testing.T) {
 					).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/new": {
 					ClusterQueue: "sales",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -1237,7 +1237,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{"sales/new"},
+			wantScheduled: []workload.Reference{"sales/new"},
 		},
 		"partial admission disabled, multiple variable pod sets": {
 			workloads: []kueue.Workload{
@@ -1258,7 +1258,7 @@ func TestSchedule(t *testing.T) {
 					).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"sales": {"sales/new"},
 			},
 			disablePartialAdmission: true,
@@ -1288,8 +1288,8 @@ func TestSchedule(t *testing.T) {
 					*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).Request("r2", "16").Obj(),
 				).Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"sales/wl1", "sales/wl2"},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantScheduled: []workload.Reference{"sales/wl1", "sales/wl2"},
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/wl1": *utiltesting.MakeAdmission("cq1", kueue.DefaultPodSetName).
 					Assignment("r1", "default", "16").AssignmentPodCount(1).
 					Obj(),
@@ -1323,8 +1323,8 @@ func TestSchedule(t *testing.T) {
 					*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).Request("r1", "14").Obj(),
 				).Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"sales/wl1", "sales/wl2"},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantScheduled: []workload.Reference{"sales/wl1", "sales/wl2"},
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/wl1": *utiltesting.MakeAdmission("cq1", kueue.DefaultPodSetName).
 					Assignment("r1", "default", "16").AssignmentPodCount(1).
 					Obj(),
@@ -1358,13 +1358,13 @@ func TestSchedule(t *testing.T) {
 					*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).Request("r1", "16").Obj(),
 				).Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"sales/wl1"},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantScheduled: []workload.Reference{"sales/wl1"},
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"sales/wl1": *utiltesting.MakeAdmission("cq1", kueue.DefaultPodSetName).
 					Assignment("r1", "default", "16").AssignmentPodCount(1).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq2": {"sales/wl2"},
 			},
 		},
@@ -1460,7 +1460,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/admitted_a": {
 					ClusterQueue: "cq_a",
 					PodSetAssignments: []kueue.PodSetAssignment{
@@ -1492,10 +1492,10 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantScheduled: []workload.WorkloadReference{
+			wantScheduled: []workload.Reference{
 				"eng-beta/b",
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq_a": {"eng-alpha/a"},
 			},
 		},
@@ -1541,13 +1541,13 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/all_nominal": *utiltesting.MakeAdmission("eng-alpha", "one").Assignment(corev1.ResourceCPU, "on-demand", "50").AssignmentPodCount(50).Obj(),
 				"eng-beta/borrowing":    *utiltesting.MakeAdmission("eng-beta", "one").Assignment(corev1.ResourceCPU, "on-demand", "55").AssignmentPodCount(55).Obj(),
 				"eng-alpha/new":         *utiltesting.MakeAdmission("eng-alpha", "one").Assignment(corev1.ResourceCPU, "on-demand", "5").AssignmentPodCount(5).Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/new"},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantScheduled: []workload.Reference{"eng-alpha/new"},
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"eng-beta": {"eng-beta/older_new"},
 			},
 		},
@@ -1675,14 +1675,14 @@ func TestSchedule(t *testing.T) {
 						PodSet).
 					Workload,
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/d0": *utiltesting.MakeAdmission("d", "one").Assignment(corev1.ResourceCPU, "on-demand", "10").Obj(),
 				"eng-alpha/e0": *utiltesting.MakeAdmission("e", "one").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
 				"eng-alpha/g0": *utiltesting.MakeAdmission("g", "one").Assignment(corev1.ResourceCPU, "on-demand", "100").Obj(),
 				"eng-alpha/d1": *utiltesting.MakeAdmission("d", "one").Assignment(corev1.ResourceCPU, "on-demand", "70").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/d1"},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantScheduled: []workload.Reference{"eng-alpha/d1"},
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"e": {"eng-alpha/e1"},
 				"g": {"eng-alpha/g1"},
 				"f": {"eng-alpha/f1"},
@@ -1743,12 +1743,12 @@ func TestSchedule(t *testing.T) {
 						PodSet).
 					Workload,
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/b0": *utiltesting.MakeAdmission("b", "one").Assignment(corev1.ResourceCPU, "on-demand", "10").Obj(),
 				"eng-alpha/b1": *utiltesting.MakeAdmission("b", "one").Assignment(corev1.ResourceCPU, "on-demand", "50").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/b1"},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantScheduled: []workload.Reference{"eng-alpha/b1"},
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"c": {"eng-alpha/c1"},
 			},
 		},
@@ -1820,12 +1820,12 @@ func TestSchedule(t *testing.T) {
 						PodSet).
 					Workload,
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("a", "one").Assignment(corev1.ResourceCPU, "on-demand", "10").Obj(),
 				"eng-alpha/b1": *utiltesting.MakeAdmission("b", "one").Assignment(corev1.ResourceCPU, "on-demand", "10").Obj(),
 				"eng-alpha/c1": *utiltesting.MakeAdmission("c", "one").Assignment(corev1.ResourceCPU, "on-demand", "10").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/a1", "eng-alpha/b1", "eng-alpha/c1"},
+			wantScheduled: []workload.Reference{"eng-alpha/a1", "eng-alpha/b1", "eng-alpha/c1"},
 			wantLeft:      nil,
 		},
 		"fair sharing schedule highest priority first": {
@@ -1874,11 +1874,11 @@ func TestSchedule(t *testing.T) {
 						PodSet).
 					Workload,
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/c1": *utiltesting.MakeAdmission("c", "one").Assignment(corev1.ResourceCPU, "on-demand", "10").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/c1"},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantScheduled: []workload.Reference{"eng-alpha/c1"},
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"b": {"eng-alpha/b1"},
 			},
 		},
@@ -1930,11 +1930,11 @@ func TestSchedule(t *testing.T) {
 						PodSet).
 					Workload,
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/c1": *utiltesting.MakeAdmission("c", "one").Assignment(corev1.ResourceCPU, "on-demand", "10").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/c1"},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantScheduled: []workload.Reference{"eng-alpha/c1"},
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"b": {"eng-alpha/b1"},
 			},
 		},
@@ -2014,11 +2014,11 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "2").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/a1", "eng-alpha/a2"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/a1", "eng-alpha/a2"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/incoming"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "on-demand", "1").Obj(),
 				"eng-alpha/a2": *utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "on-demand", "1").Obj(),
 				"eng-alpha/a3": *utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "on-demand", "1").Obj(),
@@ -2071,10 +2071,10 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "3").
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/incoming"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "on-demand", "1").Obj(),
 				"eng-beta/b1":  *utiltesting.MakeAdmission("other-beta").Assignment(corev1.ResourceCPU, "on-demand", "1").Obj(),
 			},
@@ -2122,12 +2122,12 @@ func TestSchedule(t *testing.T) {
 					Queue("main").
 					Request(corev1.ResourceCPU, "30").Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/alpha1", "eng-gamma/gamma1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/alpha1", "eng-gamma/gamma1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				// Preemptor is not admitted in this cycle.
 				"eng-beta": {"eng-beta/preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/all_spot": *utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "spot", "100").Obj(),
 				"eng-alpha/alpha1":   *utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
 				"eng-alpha/alpha2":   *utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
@@ -2193,12 +2193,12 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "2").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/a1", "eng-beta/b1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/a1", "eng-beta/b1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/preemptor"},
 				"other-beta":  {"eng-beta/preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "default", "2").Obj(),
 				"eng-beta/b1":  *utiltesting.MakeAdmission("other-beta").Assignment(corev1.ResourceCPU, "default", "2").Obj(),
 			},
@@ -2255,15 +2255,15 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "2").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-beta/b1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-beta/b1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-beta": {"eng-beta/preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/fit": *utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "default", "1").Obj(),
 				"eng-beta/b1":   *utiltesting.MakeAdmission("other-beta").Assignment(corev1.ResourceCPU, "default", "2").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/fit"},
+			wantScheduled: []workload.Reference{"eng-alpha/fit"},
 			wantSkippedPreemptions: map[string]int{
 				"other-alpha": 0,
 				"other-beta":  0,
@@ -2341,12 +2341,12 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "3").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/a1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/a1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/preemptor"},
 				"other-beta":  {"eng-beta/pretending-preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "default", "2").Obj(),
 				"eng-beta/b1":  *utiltesting.MakeAdmission("other-beta").Assignment(corev1.ResourceCPU, "default", "2").Obj(),
 			},
@@ -2445,13 +2445,13 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "3").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/a1", "eng-beta/b1", "eng-gamma/c1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/a1", "eng-beta/b1", "eng-gamma/c1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/preemptor"},
 				"other-beta":  {"eng-beta/preemptor"},
 				"other-gamma": {"eng-gamma/preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").
 					Assignment(corev1.ResourceCPU, "default", "3").Obj(),
 				"eng-beta/b1": *utiltesting.MakeAdmission("other-beta").
@@ -2559,12 +2559,12 @@ func TestSchedule(t *testing.T) {
 					Request("beta-resource", "1").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/a1", "eng-gamma/c1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/a1", "eng-gamma/c1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/preemptor"},
 				"other-beta":  {"eng-beta/pretending-preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").
 					Assignment("alpha-resource", "default", "1").Obj(),
 				"eng-beta/b1": *utiltesting.MakeAdmission("other-beta").
@@ -2587,7 +2587,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"sales": {"sales/new"},
 			},
 		},
@@ -2606,7 +2606,7 @@ func TestSchedule(t *testing.T) {
 					WithValue("Max", corev1.ResourceCPU, "300m").
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"sales": {"sales/new"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -2635,7 +2635,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"sales": {"sales/new"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -2663,7 +2663,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"sales": {"sales/new"},
 			},
 		},
@@ -2719,11 +2719,11 @@ func TestSchedule(t *testing.T) {
 					Request("gpu", "6").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-beta/b1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-beta/b1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").Assignment("gpu", "on-demand", "5").Obj(),
 				"eng-beta/b1":  *utiltesting.MakeAdmission("other-beta").Assignment("gpu", "spot", "5").Obj(),
 			},
@@ -2781,11 +2781,11 @@ func TestSchedule(t *testing.T) {
 					Request("gpu", "6").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/a1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/a1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").Assignment("gpu", "on-demand", "5").Obj(),
 				"eng-alpha/a2": *utiltesting.MakeAdmission("other-alpha").Assignment("gpu", "spot", "5").Obj(),
 				"eng-beta/b1":  *utiltesting.MakeAdmission("other-beta").Assignment("gpu", "spot", "5").Obj(),
@@ -2846,11 +2846,11 @@ func TestSchedule(t *testing.T) {
 					Request("gpu", "5").
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-alpha/a1"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-alpha/a1"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"other-alpha": {"eng-alpha/preemptor"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1": *utiltesting.MakeAdmission("other-alpha").Assignment("gpu", "on-demand", "6").Obj(),
 				"eng-alpha/a2": *utiltesting.MakeAdmission("other-alpha").Assignment("gpu", "spot", "5").Obj(),
 				"eng-beta/b1":  *utiltesting.MakeAdmission("other-beta").Assignment("gpu", "spot", "5").Obj(),
@@ -2945,14 +2945,14 @@ func TestSchedule(t *testing.T) {
 					SimpleReserveQuota("CQ3", "on-demand", now).
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("eng-gamma/Admitted-Workload-2"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("eng-gamma/Admitted-Workload-2"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"CQ2": {"eng-beta/WL2"},
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"CQ1": {"eng-alpha/WL1"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/Admitted-Workload-1": *utiltesting.MakeAdmission("CQ1").Assignment("gpu", "on-demand", "5").Obj(),
 				"eng-gamma/Admitted-Workload-2": *utiltesting.MakeAdmission("CQ3").Assignment("gpu", "on-demand", "5").Obj(),
 				"eng-gamma/Admitted-Workload-3": *utiltesting.MakeAdmission("CQ3").Assignment("gpu", "on-demand", "5").Obj(),
@@ -2997,13 +2997,13 @@ func TestSchedule(t *testing.T) {
 					Obj(),
 			},
 			wantLeft: nil,
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"ClusterQueueA": {"eng-alpha/a2-pending"},
 			},
-			wantScheduled: []workload.WorkloadReference{
+			wantScheduled: []workload.Reference{
 				"eng-beta/b1-pending",
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1-admitted": *utiltesting.MakeAdmission("ClusterQueueA").Assignment("gpu", "on-demand", "1").Obj(),
 				"eng-beta/b1-pending":   *utiltesting.MakeAdmission("ClusterQueueB").Assignment("gpu", "on-demand", "1").Obj(),
 			},
@@ -3046,13 +3046,13 @@ func TestSchedule(t *testing.T) {
 					Request("gpu", "1").
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"ClusterQueueB": {"eng-beta/b1-pending"},
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"ClusterQueueA": {"eng-alpha/a2-pending"},
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/a1-admitted": *utiltesting.MakeAdmission("ClusterQueueA").Assignment("gpu", "on-demand", "1").Obj(),
 			},
 		},
@@ -3111,11 +3111,11 @@ func TestSchedule(t *testing.T) {
 						PodSet).
 					Workload,
 			},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/guaranteed": *utiltesting.MakeAdmission("guaranteed", "one").Assignment(corev1.ResourceCPU, "default", "4").Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/guaranteed"},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantScheduled: []workload.Reference{"eng-alpha/guaranteed"},
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"best-effort": {"eng-alpha/best-effort"},
 			},
 		},
@@ -3175,8 +3175,8 @@ func TestSchedule(t *testing.T) {
 					Priority(100).
 					Obj(),
 			},
-			wantScheduled: []workload.WorkloadReference{"eng-alpha/new"},
-			wantAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantScheduled: []workload.Reference{"eng-alpha/new"},
+			wantAssignments: map[workload.Reference]kueue.Admission{
 				"eng-alpha/new":      *utiltesting.MakeAdmission("cq1").Assignment(corev1.ResourceCPU, "spot", "1").Obj(),
 				"eng-alpha/admitted": *utiltesting.MakeAdmission("cq2").Assignment(corev1.ResourceCPU, "on-demand", "1").Obj(),
 			},
@@ -3239,7 +3239,7 @@ func TestSchedule(t *testing.T) {
 			}
 
 			scheduler := New(qManager, cqCache, cl, recorder, WithFairSharing(&config.FairSharing{Enable: tc.enableFairSharing}), WithClock(t, fakeClock))
-			gotScheduled := make(map[workload.WorkloadReference]kueue.Admission)
+			gotScheduled := make(map[workload.Reference]kueue.Admission)
 			var mu sync.Mutex
 			scheduler.applyAdmission = func(ctx context.Context, w *kueue.Workload) error {
 				if tc.admissionError != nil {
@@ -3255,7 +3255,7 @@ func TestSchedule(t *testing.T) {
 				func() { wg.Add(1) },
 				func() { wg.Done() },
 			))
-			gotPreempted := sets.New[workload.WorkloadReference]()
+			gotPreempted := sets.New[workload.Reference]()
 			scheduler.preemptor.OverrideApply(func(_ context.Context, w *kueue.Workload, _, _ string) error {
 				mu.Lock()
 				gotPreempted.Insert(workload.Key(w))
@@ -3270,7 +3270,7 @@ func TestSchedule(t *testing.T) {
 			scheduler.schedule(ctx)
 			wg.Wait()
 
-			wantScheduled := make(map[workload.WorkloadReference]kueue.Admission)
+			wantScheduled := make(map[workload.Reference]kueue.Admission)
 			for _, key := range tc.wantScheduled {
 				wantScheduled[key] = tc.wantAssignments[key]
 			}
@@ -3283,7 +3283,7 @@ func TestSchedule(t *testing.T) {
 			}
 
 			// Verify assignments in cache.
-			gotAssignments := make(map[workload.WorkloadReference]kueue.Admission)
+			gotAssignments := make(map[workload.Reference]kueue.Admission)
 			var gotWorkloads []kueue.Workload
 			snapshot, err := cqCache.Snapshot(ctx)
 			if err != nil {
@@ -3750,9 +3750,9 @@ func TestLastSchedulingContext(t *testing.T) {
 		admittedWorkloads              []kueue.Workload
 		workloads                      []kueue.Workload
 		deleteWorkloads                []kueue.Workload
-		wantPreempted                  sets.Set[workload.WorkloadReference]
-		wantAdmissionsOnFirstSchedule  map[workload.WorkloadReference]kueue.Admission
-		wantAdmissionsOnSecondSchedule map[workload.WorkloadReference]kueue.Admission
+		wantPreempted                  sets.Set[workload.Reference]
+		wantAdmissionsOnFirstSchedule  map[workload.Reference]kueue.Admission
+		wantAdmissionsOnSecondSchedule map[workload.Reference]kueue.Admission
 	}{
 		{
 			name: "scheduling context not changed: use next flavor if can't preempt",
@@ -3767,9 +3767,9 @@ func TestLastSchedulingContext(t *testing.T) {
 					Obj(),
 			},
 			deleteWorkloads:               []kueue.Workload{},
-			wantPreempted:                 sets.Set[workload.WorkloadReference]{},
-			wantAdmissionsOnFirstSchedule: map[workload.WorkloadReference]kueue.Admission{},
-			wantAdmissionsOnSecondSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted:                 sets.Set[workload.Reference]{},
+			wantAdmissionsOnFirstSchedule: map[workload.Reference]kueue.Admission{},
+			wantAdmissionsOnSecondSchedule: map[workload.Reference]kueue.Admission{
 				"default/new":   *utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "spot", "20").Obj(),
 				"default/low-1": *utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "on-demand", "50").Obj(),
 			},
@@ -3789,9 +3789,9 @@ func TestLastSchedulingContext(t *testing.T) {
 			deleteWorkloads: []kueue.Workload{
 				*wl,
 			},
-			wantPreempted:                 sets.Set[workload.WorkloadReference]{},
-			wantAdmissionsOnFirstSchedule: map[workload.WorkloadReference]kueue.Admission{},
-			wantAdmissionsOnSecondSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted:                 sets.Set[workload.Reference]{},
+			wantAdmissionsOnFirstSchedule: map[workload.Reference]kueue.Admission{},
+			wantAdmissionsOnSecondSchedule: map[workload.Reference]kueue.Admission{
 				"default/preemptor": *utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
 			},
 		},
@@ -3816,12 +3816,12 @@ func TestLastSchedulingContext(t *testing.T) {
 					Obj(),
 			},
 			deleteWorkloads: []kueue.Workload{},
-			wantPreempted:   sets.Set[workload.WorkloadReference]{},
-			wantAdmissionsOnFirstSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted:   sets.Set[workload.Reference]{},
+			wantAdmissionsOnFirstSchedule: map[workload.Reference]kueue.Admission{
 				"default/workload1": *utiltesting.MakeAdmission("eng-cohort-beta").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
 				"default/borrower":  *utiltesting.MakeAdmission("eng-cohort-alpha").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
 			},
-			wantAdmissionsOnSecondSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantAdmissionsOnSecondSchedule: map[workload.Reference]kueue.Admission{
 				"default/placeholder": *utiltesting.MakeAdmission("eng-cohort-alpha").Assignment(corev1.ResourceCPU, "on-demand", "50").Obj(),
 				"default/workload1":   *utiltesting.MakeAdmission("eng-cohort-beta").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
 				"default/borrower":    *utiltesting.MakeAdmission("eng-cohort-alpha").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
@@ -3849,11 +3849,11 @@ func TestLastSchedulingContext(t *testing.T) {
 					Obj(),
 			},
 			deleteWorkloads: []kueue.Workload{},
-			wantPreempted:   sets.Set[workload.WorkloadReference]{},
-			wantAdmissionsOnFirstSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted:   sets.Set[workload.Reference]{},
+			wantAdmissionsOnFirstSchedule: map[workload.Reference]kueue.Admission{
 				"default/workload": *utiltesting.MakeAdmission("eng-cohort-theta").Assignment(corev1.ResourceCPU, "spot", "20").Obj(),
 			},
-			wantAdmissionsOnSecondSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantAdmissionsOnSecondSchedule: map[workload.Reference]kueue.Admission{
 				"default/placeholder":  *utiltesting.MakeAdmission("eng-cohort-alpha").Assignment(corev1.ResourceCPU, "on-demand", "50").Obj(),
 				"default/placeholder1": *utiltesting.MakeAdmission("eng-cohort-theta").Assignment(corev1.ResourceCPU, "on-demand", "50").Obj(),
 				"default/workload":     *utiltesting.MakeAdmission("eng-cohort-theta").Assignment(corev1.ResourceCPU, "spot", "20").Obj(),
@@ -3886,11 +3886,11 @@ func TestLastSchedulingContext(t *testing.T) {
 					Obj(),
 			},
 			deleteWorkloads: []kueue.Workload{},
-			wantPreempted:   sets.Set[workload.WorkloadReference]{},
-			wantAdmissionsOnFirstSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted:   sets.Set[workload.Reference]{},
+			wantAdmissionsOnFirstSchedule: map[workload.Reference]kueue.Admission{
 				"default/workload": *utiltesting.MakeAdmission("eng-cohort-theta").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
 			},
-			wantAdmissionsOnSecondSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantAdmissionsOnSecondSchedule: map[workload.Reference]kueue.Admission{
 				"default/placeholder":  *utiltesting.MakeAdmission("eng-cohort-alpha").Assignment(corev1.ResourceCPU, "on-demand", "40").Obj(),
 				"default/placeholder1": *utiltesting.MakeAdmission("eng-cohort-theta").Assignment(corev1.ResourceCPU, "on-demand", "40").Obj(),
 				"default/placeholder2": *utiltesting.MakeAdmission("eng-cohort-theta").Assignment(corev1.ResourceCPU, "spot", "100").Obj(),
@@ -3920,9 +3920,9 @@ func TestLastSchedulingContext(t *testing.T) {
 					Obj(),
 			},
 			deleteWorkloads:               []kueue.Workload{*utiltesting.MakeWorkload("placeholder-alpha", "default").Obj()},
-			wantPreempted:                 sets.New[workload.WorkloadReference]("default/placeholder-alpha"),
-			wantAdmissionsOnFirstSchedule: map[workload.WorkloadReference]kueue.Admission{},
-			wantAdmissionsOnSecondSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted:                 sets.New[workload.Reference]("default/placeholder-alpha"),
+			wantAdmissionsOnFirstSchedule: map[workload.Reference]kueue.Admission{},
+			wantAdmissionsOnSecondSchedule: map[workload.Reference]kueue.Admission{
 				"default/placeholder-theta-spot": *utiltesting.MakeAdmission("eng-cohort-theta").Assignment(corev1.ResourceCPU, "spot", "100").Obj(),
 				"default/new":                    *utiltesting.MakeAdmission("eng-cohort-theta").Assignment(corev1.ResourceCPU, "on-demand", "20").Obj(),
 			},
@@ -4003,8 +4003,8 @@ func TestLastSchedulingContext(t *testing.T) {
 					Obj(),
 			},
 			deleteWorkloads: []kueue.Workload{*utiltesting.MakeWorkload("alpha2", "default").Obj()},
-			wantPreempted:   sets.New[workload.WorkloadReference]("default/alpha2"),
-			wantAdmissionsOnSecondSchedule: map[workload.WorkloadReference]kueue.Admission{
+			wantPreempted:   sets.New[workload.Reference]("default/alpha2"),
+			wantAdmissionsOnSecondSchedule: map[workload.Reference]kueue.Admission{
 				"default/alpha1": *utiltesting.MakeAdmission("eng-cohort-alpha").Assignment(corev1.ResourceCPU, "on-demand", "22").Obj(),
 				"default/alpha3": *utiltesting.MakeAdmission("eng-cohort-alpha").Assignment(corev1.ResourceCPU, "spot", "22").Obj(),
 				"default/beta1":  *utiltesting.MakeAdmission("eng-cohort-beta").Assignment(corev1.ResourceCPU, "spot", "22").Obj(),
@@ -4050,7 +4050,7 @@ func TestLastSchedulingContext(t *testing.T) {
 				}
 			}
 			scheduler := New(qManager, cqCache, cl, recorder, WithClock(t, fakeClock))
-			gotScheduled := make(map[workload.WorkloadReference]kueue.Admission)
+			gotScheduled := make(map[workload.Reference]kueue.Admission)
 			var mu sync.Mutex
 			scheduler.applyAdmission = func(ctx context.Context, w *kueue.Workload) error {
 				mu.Lock()
@@ -4063,7 +4063,7 @@ func TestLastSchedulingContext(t *testing.T) {
 				func() { wg.Add(1) },
 				func() { wg.Done() },
 			))
-			gotPreempted := sets.New[workload.WorkloadReference]()
+			gotPreempted := sets.New[workload.Reference]()
 			scheduler.preemptor.OverrideApply(func(_ context.Context, w *kueue.Workload, _, _ string) error {
 				mu.Lock()
 				gotPreempted.Insert(workload.Key(w))
@@ -4104,7 +4104,7 @@ func TestLastSchedulingContext(t *testing.T) {
 				t.Errorf("Unexpected preemptions (-want,+got):\n%s", diff)
 			}
 			// Verify assignments in cache.
-			gotAssignments := make(map[workload.WorkloadReference]kueue.Admission)
+			gotAssignments := make(map[workload.Reference]kueue.Admission)
 			snapshot, err := cqCache.Snapshot(ctx)
 			if err != nil {
 				t.Fatalf("unexpected error while building snapshot: %v", err)
@@ -4138,8 +4138,8 @@ func TestRequeueAndUpdate(t *testing.T) {
 	cases := []struct {
 		name              string
 		e                 entry
-		wantWorkloads     map[kueue.ClusterQueueReference][]workload.WorkloadReference
-		wantInadmissible  map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantWorkloads     map[kueue.ClusterQueueReference][]workload.Reference
+		wantInadmissible  map[kueue.ClusterQueueReference][]workload.Reference
 		wantStatus        kueue.WorkloadStatus
 		wantStatusUpdates int
 	}{
@@ -4159,7 +4159,7 @@ func TestRequeueAndUpdate(t *testing.T) {
 				},
 				ResourceRequests: []kueue.PodSetRequest{{Name: kueue.DefaultPodSetName}},
 			},
-			wantInadmissible: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissible: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq": {workload.Key(w1)},
 			},
 			wantStatusUpdates: 1,
@@ -4170,7 +4170,7 @@ func TestRequeueAndUpdate(t *testing.T) {
 				status:          assumed,
 				inadmissibleMsg: "",
 			},
-			wantWorkloads: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantWorkloads: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq": {workload.Key(w1)},
 			},
 		},
@@ -4180,7 +4180,7 @@ func TestRequeueAndUpdate(t *testing.T) {
 				status:          nominated,
 				inadmissibleMsg: "failed to admit workload",
 			},
-			wantWorkloads: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantWorkloads: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq": {workload.Key(w1)},
 			},
 		},
@@ -4201,7 +4201,7 @@ func TestRequeueAndUpdate(t *testing.T) {
 				},
 				ResourceRequests: []kueue.PodSetRequest{{Name: kueue.DefaultPodSetName}},
 			},
-			wantWorkloads: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantWorkloads: map[kueue.ClusterQueueReference][]workload.Reference{
 				"cq": {workload.Key(w1)},
 			},
 			wantStatusUpdates: 1,
@@ -4641,11 +4641,11 @@ func TestScheduleForTAS(t *testing.T) {
 		workloads       []kueue.Workload
 
 		// wantNewAssignments is a summary of all new admissions in the cache after this cycle.
-		wantNewAssignments map[workload.WorkloadReference]kueue.Admission
+		wantNewAssignments map[workload.Reference]kueue.Admission
 		// wantLeft is the workload keys that are left in the queues after this cycle.
-		wantLeft map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantLeft map[kueue.ClusterQueueReference][]workload.Reference
 		// wantInadmissibleLeft is the workload keys that are left in the inadmissible state after this cycle.
-		wantInadmissibleLeft map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantInadmissibleLeft map[kueue.ClusterQueueReference][]workload.Reference
 		// wantEvents asserts on the events, the comparison options are passed by eventCmpOpts
 		wantEvents []utiltesting.EventRecord
 		// eventCmpOpts are the comparison options for the events
@@ -4676,7 +4676,7 @@ func TestScheduleForTAS(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -4749,7 +4749,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-reservation", "1000m").
 					AssignmentPodCount(1).
@@ -4813,7 +4813,7 @@ func TestScheduleForTAS(t *testing.T) {
 					Admitted(true).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -4870,7 +4870,7 @@ func TestScheduleForTAS(t *testing.T) {
 					Admitted(true).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -4927,7 +4927,7 @@ func TestScheduleForTAS(t *testing.T) {
 					Admitted(true).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "3000m").
 					AssignmentPodCount(1).
@@ -4992,7 +4992,7 @@ func TestScheduleForTAS(t *testing.T) {
 					Admitted(true).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -5049,7 +5049,7 @@ func TestScheduleForTAS(t *testing.T) {
 					Admitted(true).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -5106,7 +5106,7 @@ func TestScheduleForTAS(t *testing.T) {
 					Admitted(true).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -5189,7 +5189,7 @@ func TestScheduleForTAS(t *testing.T) {
 					Admitted(true).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one", "two").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -5259,7 +5259,7 @@ func TestScheduleForTAS(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "26").
 					AssignmentPodCount(26).
@@ -5342,7 +5342,7 @@ func TestScheduleForTAS(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-second", "1000m").
 					AssignmentPodCount(1).
@@ -5466,7 +5466,7 @@ func TestScheduleForTAS(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one", "two").
 					PodSets(
 						kueue.PodSetAssignment{
@@ -5541,7 +5541,7 @@ func TestScheduleForTAS(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					DelayedTopologyRequest(kueue.DelayedTopologyRequestStatePending).
@@ -5612,7 +5612,7 @@ func TestScheduleForTAS(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-second", "1000m").
 					AssignmentPodCount(1).
@@ -5657,7 +5657,7 @@ func TestScheduleForTAS(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					DelayedTopologyRequest(kueue.DelayedTopologyRequestStatePending).
@@ -5691,7 +5691,7 @@ func TestScheduleForTAS(t *testing.T) {
 					}).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -5735,7 +5735,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -5787,7 +5787,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -5838,7 +5838,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "default", "1000m").
 					AssignmentPodCount(1).
@@ -5884,7 +5884,7 @@ func TestScheduleForTAS(t *testing.T) {
 							Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					PodSets(
 						kueue.PodSetAssignment{
@@ -5949,7 +5949,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -5993,7 +5993,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -6046,7 +6046,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-custom-flavor", "1").
 					AssignmentPodCount(1).
@@ -6090,7 +6090,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -6140,7 +6140,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -6172,7 +6172,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -6230,7 +6230,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "500m").
 					AssignmentPodCount(1).
@@ -6301,7 +6301,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "500m").
 					Assignment(corev1.ResourceMemory, "tas-default", "500Mi").
@@ -6378,7 +6378,7 @@ func TestScheduleForTAS(t *testing.T) {
 							Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -6436,7 +6436,7 @@ func TestScheduleForTAS(t *testing.T) {
 							Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "launcher", "worker").
 					AssignmentWithIndex(0, corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCountWithIndex(0, 1).
@@ -6532,7 +6532,7 @@ func TestScheduleForTAS(t *testing.T) {
 							Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "launcher", "worker").
 					AssignmentWithIndex(0, corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCountWithIndex(0, 1).
@@ -6641,7 +6641,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -6724,7 +6724,7 @@ func TestScheduleForTAS(t *testing.T) {
 					).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1000m").
 					AssignmentPodCount(1).
@@ -6769,7 +6769,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1").
 					AssignmentPodCount(1).
@@ -6854,7 +6854,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -6880,7 +6880,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/foo": *utiltesting.MakeAdmission("tas-main", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "0").
 					Assignment(corev1.ResourceMemory, "tas-default", "10Mi").
@@ -6967,7 +6967,7 @@ func TestScheduleForTAS(t *testing.T) {
 					t.Fatalf("Inserting queue %s/%s in manager: %v", q.Namespace, q.Name, err)
 				}
 			}
-			initiallyAdmittedWorkloads := sets.New[workload.WorkloadReference]()
+			initiallyAdmittedWorkloads := sets.New[workload.Reference]()
 			for _, w := range tc.workloads {
 				if workload.IsAdmitted(&w) && !workload.HasNodeToReplace(&w) {
 					initiallyAdmittedWorkloads.Insert(workload.Key(&w))
@@ -6979,7 +6979,7 @@ func TestScheduleForTAS(t *testing.T) {
 				}
 			}
 			scheduler := New(qManager, cqCache, cl, recorder)
-			gotScheduled := make([]workload.WorkloadReference, 0)
+			gotScheduled := make([]workload.Reference, 0)
 			var mu sync.Mutex
 			scheduler.applyAdmission = func(ctx context.Context, w *kueue.Workload) error {
 				mu.Lock()
@@ -7003,7 +7003,7 @@ func TestScheduleForTAS(t *testing.T) {
 			if err != nil {
 				t.Fatalf("unexpected error while building snapshot: %v", err)
 			}
-			gotAssignments := make(map[workload.WorkloadReference]kueue.Admission)
+			gotAssignments := make(map[workload.Reference]kueue.Admission)
 			for cqName, c := range snapshot.ClusterQueues() {
 				for name, w := range c.Workloads {
 					if initiallyAdmittedWorkloads.Has(workload.Key(w.Obj)) {
@@ -7103,13 +7103,13 @@ func TestScheduleForTASPreemption(t *testing.T) {
 		workloads       []kueue.Workload
 
 		// wantNewAssignments is a summary of all new admissions in the cache after this cycle.
-		wantNewAssignments map[workload.WorkloadReference]kueue.Admission
+		wantNewAssignments map[workload.Reference]kueue.Admission
 		// wantLeft is the workload keys that are left in the queues after this cycle.
-		wantLeft map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantLeft map[kueue.ClusterQueueReference][]workload.Reference
 		// wantInadmissibleLeft is the workload keys that are left in the inadmissible state after this cycle.
-		wantInadmissibleLeft map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantInadmissibleLeft map[kueue.ClusterQueueReference][]workload.Reference
 		// wantPreempted is the keys of the workloads that get preempted in the scheduling cycle.
-		wantPreempted sets.Set[workload.WorkloadReference]
+		wantPreempted sets.Set[workload.Reference]
 		// wantEvents asserts on the events, the comparison options are passed by eventCmpOpts
 		wantEvents []utiltesting.EventRecord
 		// eventCmpOpts are the comparison options for the events
@@ -7157,8 +7157,8 @@ func TestScheduleForTASPreemption(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/low-priority-admitted"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("default/low-priority-admitted"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -7222,8 +7222,8 @@ func TestScheduleForTASPreemption(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/low-priority-admitted"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("default/low-priority-admitted"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/high-priority-waiting"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -7308,8 +7308,8 @@ func TestScheduleForTASPreemption(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/low-priority-admitted"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("default/low-priority-admitted"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -7396,8 +7396,8 @@ func TestScheduleForTASPreemption(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/low-priority-admitted"),
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantPreempted: sets.New[workload.Reference]("default/low-priority-admitted"),
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -7468,10 +7468,10 @@ func TestScheduleForTASPreemption(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/low-priority-which-would-fit"},
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-main": {"default/mid-priority-waiting"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -7530,14 +7530,14 @@ func TestScheduleForTASPreemption(t *testing.T) {
 					t.Fatalf("Inserting queue %s/%s in manager: %v", q.Namespace, q.Name, err)
 				}
 			}
-			initiallyAdmittedWorkloads := sets.New[workload.WorkloadReference]()
+			initiallyAdmittedWorkloads := sets.New[workload.Reference]()
 			for _, w := range tc.workloads {
 				if workload.IsAdmitted(&w) {
 					initiallyAdmittedWorkloads.Insert(workload.Key(&w))
 				}
 			}
 			scheduler := New(qManager, cqCache, cl, recorder)
-			gotScheduled := make([]workload.WorkloadReference, 0)
+			gotScheduled := make([]workload.Reference, 0)
 			var mu sync.Mutex
 			scheduler.applyAdmission = func(ctx context.Context, w *kueue.Workload) error {
 				mu.Lock()
@@ -7551,7 +7551,7 @@ func TestScheduleForTASPreemption(t *testing.T) {
 				func() { wg.Done() },
 			))
 
-			gotPreempted := sets.New[workload.WorkloadReference]()
+			gotPreempted := sets.New[workload.Reference]()
 			scheduler.preemptor.OverrideApply(func(_ context.Context, w *kueue.Workload, _, _ string) error {
 				mu.Lock()
 				gotPreempted.Insert(workload.Key(w))
@@ -7572,7 +7572,7 @@ func TestScheduleForTASPreemption(t *testing.T) {
 			if diff := cmp.Diff(tc.wantPreempted, gotPreempted); diff != "" {
 				t.Errorf("Unexpected preemptions (-want,+got):\n%s", diff)
 			}
-			gotAssignments := make(map[workload.WorkloadReference]kueue.Admission)
+			gotAssignments := make(map[workload.Reference]kueue.Admission)
 			for cqName, c := range snapshot.ClusterQueues() {
 				for name, w := range c.Workloads {
 					if initiallyAdmittedWorkloads.Has(workload.Key(w.Obj)) {
@@ -7700,13 +7700,13 @@ func TestScheduleForTASCohorts(t *testing.T) {
 		workloads       []kueue.Workload
 
 		// wantNewAssignments is a summary of all new admissions in the cache after this cycle.
-		wantNewAssignments map[workload.WorkloadReference]kueue.Admission
+		wantNewAssignments map[workload.Reference]kueue.Admission
 		// wantLeft is the workload keys that are left in the queues after this cycle.
-		wantLeft map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantLeft map[kueue.ClusterQueueReference][]workload.Reference
 		// wantInadmissibleLeft is the workload keys that are left in the inadmissible state after this cycle.
-		wantInadmissibleLeft map[kueue.ClusterQueueReference][]workload.WorkloadReference
+		wantInadmissibleLeft map[kueue.ClusterQueueReference][]workload.Reference
 		// wantPreempted is the keys of the workloads that get preempted in the scheduling cycle.
-		wantPreempted sets.Set[workload.WorkloadReference]
+		wantPreempted sets.Set[workload.Reference]
 		// wantEvents asserts on the events, the comparison options are passed by eventCmpOpts
 		wantEvents []utiltesting.EventRecord
 		// eventCmpOpts are the comparison options for the events
@@ -7726,7 +7726,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/a1": *utiltesting.MakeAdmission("tas-cq-a", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "6").
 					AssignmentPodCount(6).
@@ -7802,10 +7802,10 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-b": {"default/b1"},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/a1-admitted"),
+			wantPreempted: sets.New[workload.Reference]("default/a1-admitted"),
 			eventCmpOpts:  cmp.Options{eventIgnoreMessage},
 			wantEvents: []utiltesting.EventRecord{
 				{
@@ -7913,10 +7913,10 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-b": {"default/b1"},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/a1-admitted"),
+			wantPreempted: sets.New[workload.Reference]("default/a1-admitted"),
 			eventCmpOpts:  cmp.Options{eventIgnoreMessage},
 			wantEvents: []utiltesting.EventRecord{
 				{
@@ -8002,10 +8002,10 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-b": {"default/b1"},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/a2-admitted"),
+			wantPreempted: sets.New[workload.Reference]("default/a2-admitted"),
 			eventCmpOpts:  cmp.Options{eventIgnoreMessage},
 			wantEvents: []utiltesting.EventRecord{
 				{
@@ -8127,11 +8127,11 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-b": {"default/b1"},
 				"tas-cq-c": {"default/c1"},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/a2-admitted", "default/a3-admitted"),
+			wantPreempted: sets.New[workload.Reference]("default/a2-admitted", "default/a3-admitted"),
 			eventCmpOpts:  cmp.Options{eventIgnoreMessage},
 			wantEvents: []utiltesting.EventRecord{
 				{
@@ -8179,7 +8179,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/a1": *utiltesting.MakeAdmission("tas-cq-a", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "5").
 					AssignmentPodCount(1).
@@ -8256,7 +8256,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/a1": *utiltesting.MakeAdmission("tas-cq-a", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1").
 					AssignmentPodCount(1).
@@ -8333,7 +8333,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/a1": *utiltesting.MakeAdmission("tas-cq-a", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "1").
 					AssignmentPodCount(1).
@@ -8349,7 +8349,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						},
 					}).Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-b": {"default/b1"},
 			},
 			eventCmpOpts: cmp.Options{eventIgnoreMessage},
@@ -8394,10 +8394,10 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-b": {"default/b1"},
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/a1": *utiltesting.MakeAdmission("tas-cq-a", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "5").
 					AssignmentPodCount(5).
@@ -8457,7 +8457,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/a1": *utiltesting.MakeAdmission("tas-cq-a", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "2").
 					AssignmentPodCount(1).
@@ -8473,7 +8473,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						},
 					}).Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-b": {"default/b1"},
 			},
 			eventCmpOpts: cmp.Options{eventIgnoreMessage},
@@ -8552,11 +8552,11 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-a": {"default/a2"},
 				"tas-cq-b": {"default/b1"},
 			},
-			wantPreempted: sets.New[workload.WorkloadReference]("default/a1-admitted"),
+			wantPreempted: sets.New[workload.Reference]("default/a1-admitted"),
 			eventCmpOpts:  cmp.Options{eventIgnoreMessage},
 			wantEvents: []utiltesting.EventRecord{
 				{
@@ -8633,10 +8633,10 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-b": {"default/b1"},
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-a": {"default/a2"},
 			},
 			eventCmpOpts: cmp.Options{eventIgnoreMessage},
@@ -8710,7 +8710,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.WorkloadReference{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]workload.Reference{
 				"tas-cq-a": {"default/a2"},
 			},
 			eventCmpOpts: cmp.Options{eventIgnoreMessage},
@@ -8732,7 +8732,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 					Message:   `couldn't assign flavors to pod set one: topology "tas-single-level" allows to fit only 3 out of 4 pod(s)`,
 				},
 			},
-			wantNewAssignments: map[workload.WorkloadReference]kueue.Admission{
+			wantNewAssignments: map[workload.Reference]kueue.Admission{
 				"default/b1": *utiltesting.MakeAdmission("tas-cq-b", "one").
 					Assignment(corev1.ResourceCPU, "tas-default", "3").
 					AssignmentPodCount(3).
@@ -8796,14 +8796,14 @@ func TestScheduleForTASCohorts(t *testing.T) {
 					t.Fatalf("Inserting queue %s/%s in manager: %v", q.Namespace, q.Name, err)
 				}
 			}
-			initiallyAdmittedWorkloads := sets.New[workload.WorkloadReference]()
+			initiallyAdmittedWorkloads := sets.New[workload.Reference]()
 			for _, w := range tc.workloads {
 				if workload.IsAdmitted(&w) {
 					initiallyAdmittedWorkloads.Insert(workload.Key(&w))
 				}
 			}
 			scheduler := New(qManager, cqCache, cl, recorder)
-			gotScheduled := make([]workload.WorkloadReference, 0)
+			gotScheduled := make([]workload.Reference, 0)
 			var mu sync.Mutex
 			scheduler.applyAdmission = func(ctx context.Context, w *kueue.Workload) error {
 				mu.Lock()
@@ -8817,7 +8817,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 				func() { wg.Done() },
 			))
 
-			gotPreempted := sets.New[workload.WorkloadReference]()
+			gotPreempted := sets.New[workload.Reference]()
 			scheduler.preemptor.OverrideApply(func(_ context.Context, w *kueue.Workload, _, _ string) error {
 				mu.Lock()
 				gotPreempted.Insert(workload.Key(w))
@@ -8838,7 +8838,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 			if diff := cmp.Diff(tc.wantPreempted, gotPreempted); diff != "" {
 				t.Errorf("Unexpected preemptions (-want,+got):\n%s", diff)
 			}
-			gotAssignments := make(map[workload.WorkloadReference]kueue.Admission)
+			gotAssignments := make(map[workload.Reference]kueue.Admission)
 			for cqName, c := range snapshot.ClusterQueues() {
 				for name, w := range c.Workloads {
 					if initiallyAdmittedWorkloads.Has(workload.Key(w.Obj)) {
diff --git a/test/e2e/customconfigs/waitforpodsready_test.go b/test/e2e/customconfigs/waitforpodsready_test.go
index d8edd031d..fd3415a77 100644
--- a/test/e2e/customconfigs/waitforpodsready_test.go
+++ b/test/e2e/customconfigs/waitforpodsready_test.go
@@ -41,7 +41,7 @@ const (
 	metricsReaderClusterRoleName = "kueue-metrics-reader"
 )
 
-var _ = ginkgo.Describe("WaitForPodsReady Job Controller E2E", ginkgo.Ordered, func() {
+var _ = ginkgo.Describe("WaitForPodsReady with tiny Timeout and no RecoveryTimeout", ginkgo.Ordered, ginkgo.ContinueOnFailure, func() {
 	var (
 		ns    *corev1.Namespace
 		rf    *kueue.ResourceFlavor
@@ -74,21 +74,48 @@ var _ = ginkgo.Describe("WaitForPodsReady Job Controller E2E", ginkgo.Ordered, f
 			},
 		}
 		util.MustCreate(ctx, k8sClient, metricsReaderClusterRoleBinding)
+
+		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)),
+				},
+			}
+		})
+
+		curlPod = testingjobspod.MakePod("curl-metrics", configapi.DefaultNamespace).
+			ServiceAccountName(serviceAccountName).
+			Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
+			TerminationGracePeriod(1).
+			Obj()
+		util.MustCreate(ctx, k8sClient, curlPod)
+
+		ginkgo.By("Waiting for the curl-metrics pod to run.", func() {
+			util.WaitForPodRunning(ctx, k8sClient, curlPod)
+		})
+
+		curlContainerName = curlPod.Spec.Containers[0].Name
 	})
 
 	ginkgo.BeforeEach(func() {
 		ns = util.CreateNamespaceFromPrefixWithLog(ctx, k8sClient, "wfpr-")
 
 		rf = testing.MakeResourceFlavor("default").Obj()
-		gomega.Expect(k8sClient.Create(ctx, rf)).Should(gomega.Succeed())
+		util.MustCreate(ctx, k8sClient, rf)
 
 		cq = testing.MakeClusterQueue("cq").
 			ResourceGroup(*testing.MakeFlavorQuotas(rf.Name).Resource(corev1.ResourceCPU, "10").Obj()).
 			Obj()
-		gomega.Expect(k8sClient.Create(ctx, cq)).Should(gomega.Succeed())
+		util.MustCreate(ctx, k8sClient, cq)
 
 		lq = testing.MakeLocalQueue("lq", ns.Name).ClusterQueue(cq.Name).Obj()
-		gomega.Expect(k8sClient.Create(ctx, lq)).Should(gomega.Succeed())
+		util.MustCreate(ctx, k8sClient, lq)
 	})
 
 	ginkgo.AfterEach(func() {
@@ -99,284 +126,358 @@ var _ = ginkgo.Describe("WaitForPodsReady Job Controller E2E", ginkgo.Ordered, f
 	})
 
 	ginkgo.AfterAll(func() {
+		util.ExpectObjectToBeDeletedWithTimeout(ctx, k8sClient, curlPod, true, util.LongTimeout)
 		util.ExpectObjectToBeDeleted(ctx, k8sClient, metricsReaderClusterRoleBinding, 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)),
-					},
-				}
-			})
-
-			curlPod = testingjobspod.MakePod("curl-metrics", configapi.DefaultNamespace).
-				ServiceAccountName(serviceAccountName).
-				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-				TerminationGracePeriod(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(kueue.LocalQueueName(lq.Name)).
+				Request(corev1.ResourceCPU, "2").
+				Parallelism(1).
 				Obj()
-			util.MustCreate(ctx, k8sClient, curlPod)
+			util.MustCreate(ctx, k8sClient, job)
+		})
 
-			ginkgo.By("Waiting for the curl-metrics pod to run.", func() {
-				util.WaitForPodRunning(ctx, k8sClient, curlPod)
-			})
+		wlKey = types.NamespacedName{
+			Name:      workloadjob.GetWorkloadNameForJob(job.Name, job.UID),
+			Namespace: ns.Name,
+		}
 
-			curlContainerName = curlPod.Spec.Containers[0].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.AfterEach(func() {
-			util.ExpectObjectToBeDeletedWithTimeout(ctx, k8sClient, curlPod, true, util.LongTimeout)
+		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(wl.Status.Conditions).To(testing.HaveConditionStatusFalseAndReason(kueue.WorkloadPodsReady, kueue.WorkloadWaitForStart))
+				g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrueAndReason(kueue.WorkloadEvicted, kueue.WorkloadEvictedByPodsReadyTimeout))
+				g.Expect(wl.Status.SchedulingStats.Evictions).To(
+					gomega.BeComparableTo([]kueue.WorkloadSchedulingStatsEviction{{
+						Reason:          kueue.WorkloadEvictedByPodsReadyTimeout,
+						UnderlyingCause: kueue.WorkloadWaitForStart,
+						Count:           1,
+					}}),
+				)
+			}, util.Timeout, util.Interval).Should(gomega.Succeed())
 		})
 
-		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(kueue.LocalQueueName(lq.Name)).
-					Request(corev1.ResourceCPU, "2").
-					Parallelism(1).
-					Obj()
-				gomega.Expect(k8sClient.Create(ctx, job)).Should(gomega.Succeed())
+		ginkgo.By("verifying that the metric is updated", func() {
+			util.ExpectMetricsToBeAvailable(ctx, cfg, restClient, curlPod.Name, curlContainerName, [][]string{
+				{"kueue_evicted_workloads_once_total", cq.Name, string(kueue.WorkloadEvictedByPodsReadyTimeout), kueue.WorkloadWaitForStart, "1"},
 			})
+		})
 
-			wlKey = types.NamespacedName{
-				Name:      workloadjob.GetWorkloadNameForJob(job.Name, job.UID),
-				Namespace: ns.Name,
-			}
+		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("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("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("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(wl.Status.Conditions).To(testing.HaveConditionStatusFalseAndReason(kueue.WorkloadPodsReady, kueue.WorkloadWaitForStart))
-					g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrueAndReason(kueue.WorkloadEvicted, kueue.WorkloadEvictedByPodsReadyTimeout))
-					g.Expect(wl.Status.SchedulingStats.Evictions).To(
-						gomega.BeComparableTo([]kueue.WorkloadSchedulingStatsEviction{{
-							Reason:          kueue.WorkloadEvictedByPodsReadyTimeout,
-							UnderlyingCause: kueue.WorkloadWaitForStart,
-							Count:           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.By("verifying that the metric is updated", func() {
-				util.ExpectMetricsToBeAvailable(ctx, cfg, restClient, curlPod.Name, curlContainerName, [][]string{
-					{"kueue_evicted_workloads_once_total", cq.Name, string(kueue.WorkloadEvictedByPodsReadyTimeout), kueue.WorkloadWaitForStart, "1"},
-				})
-			})
+var _ = ginkgo.Describe("WaitForPodsReady with default Timeout and a tiny RecoveryTimeout", ginkgo.Ordered, ginkgo.ContinueOnFailure, func() {
+	var (
+		ns    *corev1.Namespace
+		rf    *kueue.ResourceFlavor
+		cq    *kueue.ClusterQueue
+		lq    *kueue.LocalQueue
+		job   *batchv1.Job
+		wl    kueue.Workload
+		wlKey types.NamespacedName
 
-			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())
-			})
+		metricsReaderClusterRoleBinding *rbacv1.ClusterRoleBinding
 
-			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())
-			})
+		curlContainerName string
+		curlPod           *corev1.Pod
+	)
 
-			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.BeforeAll(func() {
+		metricsReaderClusterRoleBinding = &rbacv1.ClusterRoleBinding{
+			ObjectMeta: metav1.ObjectMeta{Name: "metrics-reader-rolebinding"},
+			Subjects: []rbacv1.Subject{
+				{
+					Kind:      "ServiceAccount",
+					Name:      serviceAccountName,
+					Namespace: configapi.DefaultNamespace,
+				},
+			},
+			RoleRef: rbacv1.RoleRef{
+				APIGroup: rbacv1.GroupName,
+				Kind:     "ClusterRole",
+				Name:     metricsReaderClusterRoleName,
+			},
+		}
+		util.MustCreate(ctx, k8sClient, metricsReaderClusterRoleBinding)
+
+		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)),
+				},
+			}
 		})
+
+		curlPod = testingjobspod.MakePod("curl-metrics", configapi.DefaultNamespace).
+			ServiceAccountName(serviceAccountName).
+			Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
+			TerminationGracePeriod(1).
+			Obj()
+		util.MustCreate(ctx, k8sClient, curlPod)
+
+		ginkgo.By("Waiting for the curl-metrics pod to run.", func() {
+			util.WaitForPodRunning(ctx, k8sClient, curlPod)
+		})
+
+		curlContainerName = curlPod.Spec.Containers[0].Name
 	})
 
-	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.BeforeEach(func() {
+		ns = util.CreateNamespaceFromPrefixWithLog(ctx, k8sClient, "wfpr-")
+
+		rf = testing.MakeResourceFlavor("default").Obj()
+		util.MustCreate(ctx, k8sClient, rf)
+
+		cq = testing.MakeClusterQueue("cq").
+			ResourceGroup(*testing.MakeFlavorQuotas(rf.Name).Resource(corev1.ResourceCPU, "10").Obj()).
+			Obj()
+		util.MustCreate(ctx, k8sClient, cq)
+
+		lq = testing.MakeLocalQueue("lq", ns.Name).ClusterQueue(cq.Name).Obj()
+		util.MustCreate(ctx, k8sClient, lq)
+	})
+
+	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)
+		util.ExpectAllPodsInNamespaceDeleted(ctx, k8sClient, ns)
+	})
+
+	ginkgo.AfterAll(func() {
+		util.ExpectObjectToBeDeletedWithTimeout(ctx, k8sClient, curlPod, true, util.LongTimeout)
+		util.ExpectObjectToBeDeleted(ctx, k8sClient, metricsReaderClusterRoleBinding, true)
+	})
 
-			curlPod = testingjobspod.MakePod("curl-metrics", configapi.DefaultNamespace).
-				ServiceAccountName(serviceAccountName).
+	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).
-				TerminationGracePeriod(1).
+				Queue(kueue.LocalQueueName(lq.Name)).
+				Request(corev1.ResourceCPU, "2").
+				Parallelism(1).
+				BackoffLimitPerIndex(2).
+				CompletionMode(batchv1.IndexedCompletion).
+				Completions(1).
 				Obj()
-			util.MustCreate(ctx, k8sClient, curlPod)
+			util.MustCreate(ctx, k8sClient, job)
+		})
 
-			ginkgo.By("Waiting for the curl-metrics pod to run.", func() {
-				util.WaitForPodRunning(ctx, k8sClient, curlPod)
-			})
+		wlKey = types.NamespacedName{
+			Name:      workloadjob.GetWorkloadNameForJob(job.Name, job.UID),
+			Namespace: ns.Name,
+		}
 
-			curlContainerName = curlPod.Spec.Containers[0].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.AfterEach(func() {
-			util.ExpectObjectToBeDeletedWithTimeout(ctx, k8sClient, curlPod, true, util.LongTimeout)
+		ginkgo.By("simulating pod failure", func() {
+			util.WaitForActivePodsAndTerminate(ctx, k8sClient, restClient, cfg, ns.Name, 1, 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(kueue.LocalQueueName(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())
+		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(wl.Status.Conditions).To(testing.HaveConditionStatusTrueAndReason(kueue.WorkloadPodsReady, kueue.WorkloadStarted))
+				g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusFalse(kueue.WorkloadEvicted))
+				g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrue(kueue.WorkloadRequeued))
+
+				g.Expect(wl.Status.SchedulingStats.Evictions).To(
+					gomega.BeComparableTo([]kueue.WorkloadSchedulingStatsEviction{{
+						Reason:          kueue.WorkloadEvictedByPodsReadyTimeout,
+						UnderlyingCause: kueue.WorkloadWaitForRecovery,
+						Count:           1,
+					}}),
+				)
+			}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
+		})
+
+		ginkgo.By("verifying that the metric is updated", func() {
+			util.ExpectMetricsToBeAvailable(ctx, cfg, restClient, curlPod.Name, curlContainerName, [][]string{
+				{"kueue_evicted_workloads_once_total", cq.Name, string(kueue.WorkloadEvictedByPodsReadyTimeout), kueue.WorkloadWaitForRecovery, "1"},
 			})
+		})
+	})
+})
 
-			wlKey = types.NamespacedName{
-				Name:      workloadjob.GetWorkloadNameForJob(job.Name, job.UID),
-				Namespace: ns.Name,
-			}
+var _ = ginkgo.Describe("WaitForPodsReady with default Timeout and a long RecoveryTimeout", ginkgo.Ordered, ginkgo.ContinueOnFailure, func() {
+	var (
+		ns    *corev1.Namespace
+		rf    *kueue.ResourceFlavor
+		cq    *kueue.ClusterQueue
+		lq    *kueue.LocalQueue
+		job   *batchv1.Job
+		wl    kueue.Workload
+		wlKey types.NamespacedName
 
-			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())
-			})
+		metricsReaderClusterRoleBinding *rbacv1.ClusterRoleBinding
 
-			ginkgo.By("simulating pod failure", func() {
-				util.WaitForActivePodsAndTerminate(ctx, k8sClient, restClient, cfg, ns.Name, 1, 1)
-			})
+		curlContainerName string
+		curlPod           *corev1.Pod
+	)
 
-			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(wl.Status.Conditions).To(testing.HaveConditionStatusTrueAndReason(kueue.WorkloadPodsReady, kueue.WorkloadStarted))
-					g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusFalse(kueue.WorkloadEvicted))
-					g.Expect(wl.Status.Conditions).To(testing.HaveConditionStatusTrue(kueue.WorkloadRequeued))
-
-					g.Expect(wl.Status.SchedulingStats.Evictions).To(
-						gomega.BeComparableTo([]kueue.WorkloadSchedulingStatsEviction{{
-							Reason:          kueue.WorkloadEvictedByPodsReadyTimeout,
-							UnderlyingCause: kueue.WorkloadWaitForRecovery,
-							Count:           1,
-						}}),
-					)
-				}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
-			})
+	ginkgo.BeforeAll(func() {
+		metricsReaderClusterRoleBinding = &rbacv1.ClusterRoleBinding{
+			ObjectMeta: metav1.ObjectMeta{Name: "metrics-reader-rolebinding"},
+			Subjects: []rbacv1.Subject{
+				{
+					Kind:      "ServiceAccount",
+					Name:      serviceAccountName,
+					Namespace: configapi.DefaultNamespace,
+				},
+			},
+			RoleRef: rbacv1.RoleRef{
+				APIGroup: rbacv1.GroupName,
+				Kind:     "ClusterRole",
+				Name:     metricsReaderClusterRoleName,
+			},
+		}
+		util.MustCreate(ctx, k8sClient, metricsReaderClusterRoleBinding)
 
-			ginkgo.By("verifying that the metric is updated", func() {
-				util.ExpectMetricsToBeAvailable(ctx, cfg, restClient, curlPod.Name, curlContainerName, [][]string{
-					{"kueue_evicted_workloads_once_total", cq.Name, string(kueue.WorkloadEvictedByPodsReadyTimeout), kueue.WorkloadWaitForRecovery, "1"},
-				})
-			})
+		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)),
+				},
+			}
 		})
+
+		curlPod = testingjobspod.MakePod("curl-metrics", configapi.DefaultNamespace).
+			ServiceAccountName(serviceAccountName).
+			Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
+			TerminationGracePeriod(1).
+			Obj()
+		util.MustCreate(ctx, k8sClient, curlPod)
+
+		ginkgo.By("Waiting for the curl-metrics pod to run.", func() {
+			util.WaitForPodRunning(ctx, k8sClient, curlPod)
+		})
+
+		curlContainerName = curlPod.Spec.Containers[0].Name
 	})
 
-	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.BeforeEach(func() {
+		ns = util.CreateNamespaceFromPrefixWithLog(ctx, k8sClient, "wfpr-")
 
-			curlPod = testingjobspod.MakePod("curl-metrics", configapi.DefaultNamespace).
-				ServiceAccountName(serviceAccountName).
-				Image(util.E2eTestAgnHostImage, util.BehaviorWaitForDeletion).
-				TerminationGracePeriod(1).
-				Obj()
-			util.MustCreate(ctx, k8sClient, curlPod)
+		rf = testing.MakeResourceFlavor("default").Obj()
+		util.MustCreate(ctx, k8sClient, rf)
 
-			ginkgo.By("Waiting for the curl-metrics pod to run.", func() {
-				util.WaitForPodRunning(ctx, k8sClient, curlPod)
-			})
+		cq = testing.MakeClusterQueue("cq").
+			ResourceGroup(*testing.MakeFlavorQuotas(rf.Name).Resource(corev1.ResourceCPU, "10").Obj()).
+			Obj()
+		util.MustCreate(ctx, k8sClient, cq)
 
-			curlContainerName = curlPod.Spec.Containers[0].Name
-		})
+		lq = testing.MakeLocalQueue("lq", ns.Name).ClusterQueue(cq.Name).Obj()
+		util.MustCreate(ctx, k8sClient, lq)
+	})
 
-		ginkgo.AfterEach(func() {
-			util.ExpectObjectToBeDeletedWithTimeout(ctx, k8sClient, curlPod, true, util.LongTimeout)
-		})
+	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)
+		util.ExpectAllPodsInNamespaceDeleted(ctx, k8sClient, ns)
+	})
 
-		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(kueue.LocalQueueName(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())
-			})
+	ginkgo.AfterAll(func() {
+		util.ExpectObjectToBeDeletedWithTimeout(ctx, k8sClient, curlPod, true, util.LongTimeout)
+		util.ExpectObjectToBeDeleted(ctx, k8sClient, metricsReaderClusterRoleBinding, true)
+	})
 
-			wlKey = types.NamespacedName{
-				Name:      workloadjob.GetWorkloadNameForJob(job.Name, job.UID),
-				Namespace: ns.Name,
-			}
+	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(kueue.LocalQueueName(lq.Name)).
+				Request(corev1.ResourceCPU, "2").
+				Parallelism(1).
+				BackoffLimitPerIndex(2).
+				CompletionMode(batchv1.IndexedCompletion).
+				Completions(1).
+				Obj()
+			util.MustCreate(ctx, k8sClient, job)
+		})
 
-			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())
-			})
+		wlKey = types.NamespacedName{
+			Name:      workloadjob.GetWorkloadNameForJob(job.Name, job.UID),
+			Namespace: ns.Name,
+		}
 
-			ginkgo.By("verifying that the metric is updated", func() {
-				util.ExpectMetricsToBeAvailable(ctx, cfg, restClient, curlPod.Name, curlContainerName, [][]string{
-					{"kueue_ready_wait_time_seconds_count", cq.Name},
-					{"kueue_admitted_until_ready_wait_time_seconds_count", cq.Name},
-					{"kueue_local_queue_ready_wait_time_seconds", ns.Name, lq.Name},
-					{"kueue_local_queue_admitted_until_ready_wait_time_seconds", ns.Name, lq.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 metric is updated", func() {
+			util.ExpectMetricsToBeAvailable(ctx, cfg, restClient, curlPod.Name, curlContainerName, [][]string{
+				{"kueue_ready_wait_time_seconds_count", cq.Name},
+				{"kueue_admitted_until_ready_wait_time_seconds_count", cq.Name},
+				{"kueue_local_queue_ready_wait_time_seconds", ns.Name, lq.Name},
+				{"kueue_local_queue_admitted_until_ready_wait_time_seconds", ns.Name, lq.Name}})
+		})
 
-			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(wl.Status.Conditions).To(testing.HaveConditionStatusTrueAndReason(kueue.WorkloadPodsReady, kueue.WorkloadRecovered))
-				}, 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(wl.Status.Conditions).To(testing.HaveConditionStatusTrueAndReason(kueue.WorkloadPodsReady, kueue.WorkloadRecovered))
+			}, util.LongTimeout, util.Interval).Should(gomega.Succeed())
+		})
 
-			ginkgo.By("verifying that the metric is not updated", func() {
-				util.ExpectMetricsNotToBeAvailable(ctx, cfg, restClient, curlPod.Name, curlContainerName, [][]string{
-					{"kueue_evicted_workloads_once_total", ns.Name},
-				})
+		ginkgo.By("verifying that the metric is not updated", func() {
+			util.ExpectMetricsNotToBeAvailable(ctx, cfg, restClient, curlPod.Name, curlContainerName, [][]string{
+				{"kueue_evicted_workloads_once_total", ns.Name},
 			})
 		})
 	})
diff --git a/test/integration/singlecluster/scheduler/scheduler_test.go b/test/integration/singlecluster/scheduler/scheduler_test.go
index d172b5667..9d8905c26 100644
--- a/test/integration/singlecluster/scheduler/scheduler_test.go
+++ b/test/integration/singlecluster/scheduler/scheduler_test.go
@@ -473,7 +473,11 @@ var _ = ginkgo.Describe("Scheduler", func() {
 
 			ginkgo.By("checking the first workload gets created and gets quota reserved", func() {
 				util.MustCreate(ctx, k8sClient, wl1)
-				util.ExpectWorkloadToBeAdmittedAs(ctx, k8sClient, wl1, nil)
+				wl1Admission := testing.MakeAdmission(admissionCheckClusterQ.Name).
+					Assignment(corev1.ResourceCPU, kueue.ResourceFlavorReference(onDemandFlavor.Name), "2").
+					AssignmentPodCount(1).
+					Obj()
+				util.ExpectWorkloadToBeAdmittedAs(ctx, k8sClient, wl1, wl1Admission)
 				util.ExpectPendingWorkloadsMetric(admissionCheckClusterQ, 0, 0)
 				util.ExpectReservingActiveWorkloadsMetric(admissionCheckClusterQ, 1)
 				util.ExpectQuotaReservedWorkloadsTotalMetric(admissionCheckClusterQ, 1)
diff --git a/test/util/util.go b/test/util/util.go
index 912e86ef5..03be84ca5 100644
--- a/test/util/util.go
+++ b/test/util/util.go
@@ -526,18 +526,18 @@ func ExpectLQAdmittedWorkloadsTotalMetric(lq *kueue.LocalQueue, value int) {
 }
 
 func ExpectLQByStatusMetric(lq *kueue.LocalQueue, status metav1.ConditionStatus) {
-	for i, s := range metrics.ConditionStatusValues {
-		var wantV float64
-		if metrics.ConditionStatusValues[i] == status {
-			wantV = 1
-		}
-		metric := metrics.LocalQueueByStatus.WithLabelValues(lq.Name, lq.Namespace, string(s))
-		gomega.EventuallyWithOffset(1, func(g gomega.Gomega) {
+	gomega.EventuallyWithOffset(1, func(g gomega.Gomega) {
+		for i, s := range metrics.ConditionStatusValues {
+			var wantV float64
+			if metrics.ConditionStatusValues[i] == status {
+				wantV = 1
+			}
+			metric := metrics.LocalQueueByStatus.WithLabelValues(lq.Name, lq.Namespace, string(s))
 			v, err := testutil.GetGaugeMetricValue(metric)
 			g.Expect(err).ToNot(gomega.HaveOccurred())
 			g.Expect(v).Should(gomega.Equal(wantV), "local_queue_status with status=%s", s)
-		}, Timeout, Interval).Should(gomega.Succeed())
-	}
+		}
+	}, Timeout, Interval).Should(gomega.Succeed())
 }
 
 func ExpectPendingWorkloadsMetric(cq *kueue.ClusterQueue, active, inadmissible int) {