From 4b0eff59c079b436d402e52075104f268b89d176 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=83=A1=E7=8E=AE=E6=96=87?= Date: Sat, 13 Sep 2025 12:24:35 +0800 Subject: [PATCH] scheduler/volumebinding: target AssumeCache UT generic passiveAssumeCache And removing duplicate tests --- .../volumebinding/assume_cache_test.go | 546 +++++++----------- 1 file changed, 195 insertions(+), 351 deletions(-) diff --git a/pkg/scheduler/framework/plugins/volumebinding/assume_cache_test.go b/pkg/scheduler/framework/plugins/volumebinding/assume_cache_test.go index 21e2d00bdb2..ab6e2608e79 100644 --- a/pkg/scheduler/framework/plugins/volumebinding/assume_cache_test.go +++ b/pkg/scheduler/framework/plugins/volumebinding/assume_cache_test.go @@ -20,8 +20,8 @@ import ( "fmt" "testing" - v1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/client-go/tools/cache" "k8s.io/component-helpers/storage/volume" "k8s.io/klog/v2/ktesting" @@ -64,354 +64,204 @@ func (i *testInformer) delete(obj interface{}) { i.handler.OnDelete(obj) } -func newTestPVCache(t *testing.T) (*testInformer, PVAssumeCache) { - logger, _ := ktesting.NewTestContext(t) - informer := &testInformer{ - indexer: cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{}), - t: t, - } - cache, err := NewPVAssumeCache(logger, informer) +func verifyList(t *testing.T, cache testCache, expected map[string]*testObj, indexedValue string) { + t.Helper() + got, err := cache.ByIndex(testIndex, indexedValue) if err != nil { - t.Fatalf("NewPVAssumeCache() failed: %v", err) + t.Fatalf("failed to get indexed objects: %v", err) } - return informer, cache -} - -func verifyListPVs(t *testing.T, cache PVAssumeCache, expectedPVs map[string]*v1.PersistentVolume, storageClassName string) { - pvList, err := cache.ListPVs(storageClassName) - if err != nil { - t.Errorf("ListPVs() failed: %v", err) + if len(got) != len(expected) { + t.Errorf("ByIndex() returned %v objects, expected %v", len(got), len(expected)) } - if len(pvList) != len(expectedPVs) { - t.Errorf("ListPVs() returned %v PVs, expected %v", len(pvList), len(expectedPVs)) - } - for _, pv := range pvList { - expectedPV, ok := expectedPVs[pv.Name] + for _, obj := range got { + expected, ok := expected[obj.Name] if !ok { - t.Errorf("ListPVs() returned unexpected PV %q", pv.Name) + t.Errorf("ByIndex() returned unexpected object %q", obj.Name) } - if expectedPV != pv { - t.Errorf("ListPVs() returned PV %p, expected %p", pv, expectedPV) + if expected != obj { + t.Errorf("ByIndex() returned object %p, expected %p", obj, expected) } } } -func verifyPV(cache PVAssumeCache, name string, expectedPV *v1.PersistentVolume) error { - pv, err := cache.Get(name) - if err != nil { - return err - } - if pv != expectedPV { - return fmt.Errorf("Get() returned %p, expected %p", pv, expectedPV) - } - return nil -} - -func TestAssumePV(t *testing.T) { - scenarios := map[string]struct { - oldPV *v1.PersistentVolume - newPV *v1.PersistentVolume - shouldSucceed bool - }{ - "success-same-version": { - oldPV: makePV("pv1", "").withVersion("5").PersistentVolume, - newPV: makePV("pv1", "").withVersion("5").PersistentVolume, - shouldSucceed: true, - }, - "success-storageclass-same-version": { - oldPV: makePV("pv1", "class1").withVersion("5").PersistentVolume, - newPV: makePV("pv1", "class1").withVersion("5").PersistentVolume, - shouldSucceed: true, - }, - "fail-new-higher-version": { - oldPV: makePV("pv1", "").withVersion("5").PersistentVolume, - newPV: makePV("pv1", "").withVersion("6").PersistentVolume, - shouldSucceed: false, - }, - "fail-old-not-found": { - oldPV: makePV("pv2", "").withVersion("5").PersistentVolume, - newPV: makePV("pv1", "").withVersion("5").PersistentVolume, - shouldSucceed: false, - }, - "fail-new-lower-version": { - oldPV: makePV("pv1", "").withVersion("5").PersistentVolume, - newPV: makePV("pv1", "").withVersion("4").PersistentVolume, - shouldSucceed: false, - }, - "fail-new-bad-version": { - oldPV: makePV("pv1", "").withVersion("5").PersistentVolume, - newPV: makePV("pv1", "").withVersion("a").PersistentVolume, - shouldSucceed: false, - }, - "fail-old-bad-version": { - oldPV: makePV("pv1", "").withVersion("a").PersistentVolume, - newPV: makePV("pv1", "").withVersion("5").PersistentVolume, - shouldSucceed: false, - }, - } - - for name, scenario := range scenarios { - t.Run(name, func(t *testing.T) { - informer, cache := newTestPVCache(t) - // Add oldPV to cache - informer.add(scenario.oldPV) - if err := verifyPV(cache, scenario.oldPV.Name, scenario.oldPV); err != nil { - t.Fatalf("Failed to Get() after initial update: %v", err) - } - - // Assume newPV - err := cache.Assume(scenario.newPV) - if scenario.shouldSucceed && err != nil { - t.Errorf("Test %q failed: Assume() returned error %v", name, err) - } - if !scenario.shouldSucceed && err == nil { - t.Errorf("Test %q failed: Assume() returned success but expected error", name) - } - - // Check that Get returns correct PV - expectedPV := scenario.newPV - if !scenario.shouldSucceed { - expectedPV = scenario.oldPV - } - if err := verifyPV(cache, scenario.oldPV.Name, expectedPV); err != nil { - t.Errorf("Failed to Get() after initial update: %v", err) - } - }) - } -} - -func TestRestorePV(t *testing.T) { - informer, cache := newTestPVCache(t) - - oldPV := makePV("pv1", "").withVersion("5").PersistentVolume - newPV := makePV("pv1", "").withVersion("5").PersistentVolume - - // Restore PV that doesn't exist - cache.Restore(&v1.PersistentVolume{}) - - // Add oldPV to cache - informer.add(oldPV) - if err := verifyPV(cache, oldPV.Name, oldPV); err != nil { - t.Fatalf("Failed to Get() after initial update: %v", err) - } - - // Restore PV - cache.Restore(oldPV) - if err := verifyPV(cache, oldPV.Name, oldPV); err != nil { - t.Fatalf("Failed to Get() after initial restore: %v", err) - } - - // Assume newPV - if err := cache.Assume(newPV); err != nil { - t.Fatalf("Assume() returned error %v", err) - } - if err := verifyPV(cache, oldPV.Name, newPV); err != nil { - t.Fatalf("Failed to Get() after Assume: %v", err) - } - - // Restore PV - cache.Restore(newPV) - if err := verifyPV(cache, oldPV.Name, oldPV); err != nil { - t.Fatalf("Failed to Get() after restore: %v", err) - } -} - -func TestBasicPVCache(t *testing.T) { - informer, cache := newTestPVCache(t) +func TestBasicCache(t *testing.T) { + informer, cache := newTestCache(t) // Get object that doesn't exist - pv, err := cache.Get("nothere") + obj, err := cache.Get("nothere") if err == nil { t.Errorf("Get() returned unexpected success") } - if pv != nil { - t.Errorf("Get() returned unexpected PV %q", pv.Name) + if obj != nil { + t.Errorf("Get() returned unexpected PV %q", obj.Name) } - // Add a bunch of PVs - pvs := map[string]*v1.PersistentVolume{} - for i := 0; i < 10; i++ { - pv := makePV(fmt.Sprintf("test-pv%v", i), "").withVersion("1").PersistentVolume - pvs[pv.Name] = pv - informer.add(pv) + // Add a bunch of objects + objects := map[string]*testObj{} + for i := range 10 { + obj := makeObj(fmt.Sprintf("test-%v", i), "1", "") + objects[obj.Name] = obj + informer.add(obj) } // List them - verifyListPVs(t, cache, pvs, "") + verifyList(t, cache, objects, "") - // Update a PV - updatedPV := makePV("test-pv3", "").withVersion("2").PersistentVolume - informer.update(pvs["test-pv3"], updatedPV) - pvs[updatedPV.Name] = updatedPV + // Update an object + updated := makeObj("test-3", "1", "") + informer.update(objects["test-3"], updated) + objects[updated.Name] = updated // List them - verifyListPVs(t, cache, pvs, "") + verifyList(t, cache, objects, "") - // Delete a PV - deletedPV := pvs["test-pv7"] - delete(pvs, deletedPV.Name) + // Delete an object + deleted := objects["test-7"] + delete(objects, deleted.Name) + informer.delete(deleted) + + // List them + verifyList(t, cache, objects, "") +} + +func TestPVCacheWithIndex(t *testing.T) { + informer, cache := newTestCache(t) + + // Add a bunch of objects + objects1 := map[string]*testObj{} + for i := range 10 { + obj := makeObj(fmt.Sprintf("test-%v", i), "1", "") + obj.Annotations["test"] = "test1" + objects1[obj.Name] = obj + informer.add(obj) + } + + // Add a bunch of objects + objects2 := map[string]*testObj{} + for i := range 10 { + obj := makeObj(fmt.Sprintf("test2-%v", i), "1", "") + obj.Annotations["test"] = "test2" + objects2[obj.Name] = obj + informer.add(obj) + } + + // List them + verifyList(t, cache, objects1, "test1") + verifyList(t, cache, objects2, "test2") + + // Update an object + updated := makeObj("test-3", "2", "") + updated.Annotations["test"] = "test1" + informer.update(objects1[updated.Name], updated) + objects1[updated.Name] = updated + + // List them + verifyList(t, cache, objects1, "test1") + verifyList(t, cache, objects2, "test2") + + // Delete an object + deletedPV := objects1["test-7"] + delete(objects1, deletedPV.Name) informer.delete(deletedPV) // List them - verifyListPVs(t, cache, pvs, "") + verifyList(t, cache, objects1, "test1") + verifyList(t, cache, objects2, "test2") } -func TestPVCacheWithStorageClasses(t *testing.T) { - informer, cache := newTestPVCache(t) +type testObj = metav1.ObjectMeta - // Add a bunch of PVs - pvs1 := map[string]*v1.PersistentVolume{} - for i := 0; i < 10; i++ { - pv := makePV(fmt.Sprintf("test-pv%v", i), "class1").withVersion("1").PersistentVolume - pvs1[pv.Name] = pv - informer.add(pv) - } - - // Add a bunch of PVs - pvs2 := map[string]*v1.PersistentVolume{} - for i := 0; i < 10; i++ { - pv := makePV(fmt.Sprintf("test2-pv%v", i), "class2").withVersion("1").PersistentVolume - pvs2[pv.Name] = pv - informer.add(pv) - } - - // List them - verifyListPVs(t, cache, pvs1, "class1") - verifyListPVs(t, cache, pvs2, "class2") - - // Update a PV - updatedPV := makePV("test-pv3", "class1").withVersion("2").PersistentVolume - informer.update(pvs1[updatedPV.Name], updatedPV) - pvs1[updatedPV.Name] = updatedPV - - // List them - verifyListPVs(t, cache, pvs1, "class1") - verifyListPVs(t, cache, pvs2, "class2") - - // Delete a PV - deletedPV := pvs1["test-pv7"] - delete(pvs1, deletedPV.Name) - informer.delete(deletedPV) - - // List them - verifyListPVs(t, cache, pvs1, "class1") - verifyListPVs(t, cache, pvs2, "class2") -} - -func TestAssumeUpdatePVCache(t *testing.T) { - informer, cache := newTestPVCache(t) - - pvName := "test-pv0" - - // Add a PV - pv := makePV(pvName, "").withVersion("1").PersistentVolume - informer.add(pv) - if err := verifyPV(cache, pvName, pv); err != nil { - t.Fatalf("failed to get PV: %v", err) - } - - // Assume PV - newPV := pv.DeepCopy() - newPV.Spec.ClaimRef = &v1.ObjectReference{Name: "test-claim"} - if err := cache.Assume(newPV); err != nil { - t.Fatalf("failed to assume PV: %v", err) - } - if err := verifyPV(cache, pvName, newPV); err != nil { - t.Fatalf("failed to get PV after assume: %v", err) - } - - // Add old PV (resync) - informer.add(pv) - if err := verifyPV(cache, pvName, newPV); err != nil { - t.Fatalf("failed to get PV after old PV added: %v", err) +func makeObj(name, version, namespace string) *testObj { + return &testObj{ + Name: name, + Namespace: namespace, + ResourceVersion: version, + Annotations: map[string]string{}, } } -func makeClaim(name, version, namespace string) *v1.PersistentVolumeClaim { - return &v1.PersistentVolumeClaim{ - ObjectMeta: metav1.ObjectMeta{ - Name: name, - Namespace: namespace, - ResourceVersion: version, - Annotations: map[string]string{}, - }, - } -} +type testCache = *passiveAssumeCache[*testObj] -func verifyPVC(cache PVCAssumeCache, pvcKey string, expectedPVC *v1.PersistentVolumeClaim) error { - pvc, err := cache.Get(pvcKey) +func verifyObj(cache testCache, key string, expected *testObj) error { + obj, err := cache.Get(key) if err != nil { return err } - if pvc != expectedPVC { - return fmt.Errorf("Get() returned %p, expected %p", pvc, expectedPVC) + if obj != expected { + return fmt.Errorf("Get() returned %p, expected %p", obj, expected) } return nil } -func newTestPVCCache(t *testing.T) (*testInformer, PVCAssumeCache) { +const testIndex = "testIndex" + +func newTestCache(t *testing.T) (*testInformer, testCache) { logger, _ := ktesting.NewTestContext(t) informer := &testInformer{ - indexer: cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{}), - t: t, + indexer: cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{ + testIndex: func(obj interface{}) ([]string, error) { + return []string{obj.(*testObj).Annotations["test"]}, nil + }, + }), + t: t, } - cache, err := NewPVCAssumeCache(logger, informer) + cache, err := newAssumeCache[*testObj](logger, informer, schema.GroupResource{Resource: "tests"}) if err != nil { - t.Fatalf("NewPVCAssumeCache() failed: %v", err) + t.Fatalf("newAssumeCache() failed: %v", err) } return informer, cache } -func TestAssumePVC(t *testing.T) { +func TestAssume(t *testing.T) { scenarios := map[string]struct { - oldPVC *v1.PersistentVolumeClaim - newPVC *v1.PersistentVolumeClaim + old *testObj + new *testObj shouldSucceed bool }{ "success-same-version": { - oldPVC: makeClaim("pvc1", "5", "ns1"), - newPVC: makeClaim("pvc1", "5", "ns1"), + old: makeObj("pvc1", "5", "ns1"), + new: makeObj("pvc1", "5", "ns1"), shouldSucceed: true, }, "fail-new-higher-version": { - oldPVC: makeClaim("pvc1", "5", "ns1"), - newPVC: makeClaim("pvc1", "6", "ns1"), + old: makeObj("pvc1", "5", "ns1"), + new: makeObj("pvc1", "6", "ns1"), shouldSucceed: false, }, "fail-old-not-found": { - oldPVC: makeClaim("pvc2", "5", "ns1"), - newPVC: makeClaim("pvc1", "5", "ns1"), + old: makeObj("pvc2", "5", "ns1"), + new: makeObj("pvc1", "5", "ns1"), shouldSucceed: false, }, "fail-new-lower-version": { - oldPVC: makeClaim("pvc1", "5", "ns1"), - newPVC: makeClaim("pvc1", "4", "ns1"), + old: makeObj("pvc1", "5", "ns1"), + new: makeObj("pvc1", "4", "ns1"), shouldSucceed: false, }, "fail-new-bad-version": { - oldPVC: makeClaim("pvc1", "5", "ns1"), - newPVC: makeClaim("pvc1", "a", "ns1"), + old: makeObj("pvc1", "5", "ns1"), + new: makeObj("pvc1", "a", "ns1"), shouldSucceed: false, }, "fail-old-bad-version": { - oldPVC: makeClaim("pvc1", "a", "ns1"), - newPVC: makeClaim("pvc1", "5", "ns1"), + old: makeObj("pvc1", "a", "ns1"), + new: makeObj("pvc1", "5", "ns1"), shouldSucceed: false, }, } for name, scenario := range scenarios { t.Run(name, func(t *testing.T) { - informer, cache := newTestPVCCache(t) + informer, cache := newTestCache(t) - // Add oldPVC to cache - informer.add(scenario.oldPVC) - if err := verifyPVC(cache, getPVCName(scenario.oldPVC), scenario.oldPVC); err != nil { + // Add old to cache + informer.add(scenario.old) + if err := verifyObj(cache, keyOf(scenario.old), scenario.old); err != nil { t.Fatalf("Failed to Get() after initial update: %v", err) } - // Assume newPVC - err := cache.Assume(scenario.newPVC) + // Assume new + err := cache.Assume(scenario.new) if scenario.shouldSucceed && err != nil { t.Errorf("Test %q failed: Assume() returned error %v", name, err) } @@ -419,142 +269,136 @@ func TestAssumePVC(t *testing.T) { t.Errorf("Test %q failed: Assume() returned success but expected error", name) } - // Check that Get returns correct PVC - expectedPV := scenario.newPVC + // Check that Get returns correct version + expectedPV := scenario.new if !scenario.shouldSucceed { - expectedPV = scenario.oldPVC + expectedPV = scenario.old } - if err := verifyPVC(cache, getPVCName(scenario.oldPVC), expectedPV); err != nil { + if err := verifyObj(cache, keyOf(scenario.old), expectedPV); err != nil { t.Errorf("Failed to Get() after initial update: %v", err) } }) } } -func TestRestorePVC(t *testing.T) { - informer, cache := newTestPVCCache(t) +func TestRestore(t *testing.T) { + informer, cache := newTestCache(t) - oldPVC := makeClaim("pvc1", "5", "ns1") - newPVC := makeClaim("pvc1", "5", "ns1") + old := makeObj("pvc1", "5", "ns1") + new := makeObj("pvc1", "5", "ns1") - // Restore PVC that doesn't exist - cache.Restore(&v1.PersistentVolumeClaim{}) + // Restore object that doesn't exist + cache.Restore(&testObj{}) - // Add oldPVC to cache - informer.add(oldPVC) - if err := verifyPVC(cache, getPVCName(oldPVC), oldPVC); err != nil { + // Add old to cache + informer.add(old) + if err := verifyObj(cache, keyOf(old), old); err != nil { t.Fatalf("Failed to Get() after initial update: %v", err) } - // Restore PVC - cache.Restore(oldPVC) - if err := verifyPVC(cache, getPVCName(oldPVC), oldPVC); err != nil { + // Restore + cache.Restore(old) + if err := verifyObj(cache, keyOf(old), old); err != nil { t.Fatalf("Failed to Get() after initial restore: %v", err) } - // Assume newPVC - if err := cache.Assume(newPVC); err != nil { + // Assume new + if err := cache.Assume(new); err != nil { t.Fatalf("Assume() returned error %v", err) } - if err := verifyPVC(cache, getPVCName(oldPVC), newPVC); err != nil { + if err := verifyObj(cache, keyOf(old), new); err != nil { t.Fatalf("Failed to Get() after Assume: %v", err) } - // Restore PVC - cache.Restore(newPVC) - if err := verifyPVC(cache, getPVCName(oldPVC), oldPVC); err != nil { + // Restore + cache.Restore(new) + if err := verifyObj(cache, keyOf(old), old); err != nil { t.Fatalf("Failed to Get() after restore: %v", err) } } -func TestConcurrentAssumePVC(t *testing.T) { - informer, cache := newTestPVCCache(t) +func TestConcurrentAssume(t *testing.T) { + informer, cache := newTestCache(t) - pvc1 := makeClaim("pvc1", "5", "ns1") - pvc1Update := makeClaim("pvc1", "5", "ns1") - // Add PVC to cache - informer.add(pvc1) + obj1 := makeObj("pvc1", "5", "ns1") + obj1Update := makeObj("pvc1", "5", "ns1") + // Add object to cache + informer.add(obj1) - // Update PVC 1 - if err := cache.Assume(pvc1Update); err != nil { + // Update obj 1 + if err := cache.Assume(obj1Update); err != nil { t.Fatalf("Assume() returned error %v", err) } - if err := verifyPVC(cache, getPVCName(pvc1Update), pvc1Update); err != nil { + if err := verifyObj(cache, keyOf(obj1Update), obj1Update); err != nil { t.Fatalf("Failed to Get() after Assume: %v", err) } - pvc2 := makeClaim("pvc1", "7", "ns1") - pvc2Update := makeClaim("pvc1", "7", "ns1") - // PVC updated externally - informer.add(pvc2) + obj2 := makeObj("pvc1", "7", "ns1") + obj2Update := makeObj("pvc1", "7", "ns1") + // obj updated externally + informer.add(obj2) - // Update PVC 2 - if err := cache.Assume(pvc2Update); err != nil { + // Update obj 2 + if err := cache.Assume(obj2Update); err != nil { t.Fatalf("Assume() returned error %v", err) } - // PVC 1 failed with conflict - cache.Restore(pvc1Update) - // Should still have pvc 2 in cache - if err := verifyPVC(cache, getPVCName(pvc2Update), pvc2Update); err != nil { + // obj 1 failed with conflict + cache.Restore(obj1Update) + // Should still have obj 2 in cache + if err := verifyObj(cache, keyOf(obj2Update), obj2Update); err != nil { t.Fatalf("Failed to Get() after restore: %v", err) } } -func TestAssumeUpdatePVCCache(t *testing.T) { - informer, cache := newTestPVCCache(t) +func TestAssumeUpdateCache(t *testing.T) { + informer, cache := newTestCache(t) - pvcName := "test-pvc0" - pvcNamespace := "test-ns" - - // Add a PVC - pvc := makeClaim(pvcName, "1", pvcNamespace) - informer.add(pvc) - if err := verifyPVC(cache, getPVCName(pvc), pvc); err != nil { - t.Fatalf("failed to get PVC: %v", err) + // Add a object + obj := makeObj("test-pvc0", "1", "test-ns") + informer.add(obj) + if err := verifyObj(cache, keyOf(obj), obj); err != nil { + t.Fatalf("failed to get: %v", err) } - // Assume PVC - newPVC := pvc.DeepCopy() - newPVC.Annotations[volume.AnnSelectedNode] = "test-node" - if err := cache.Assume(newPVC); err != nil { - t.Fatalf("failed to assume PVC: %v", err) + // Assume + newObj := obj.DeepCopy() + newObj.Annotations[volume.AnnSelectedNode] = "test-node" + if err := cache.Assume(newObj); err != nil { + t.Fatalf("failed to assume: %v", err) } - if err := verifyPVC(cache, getPVCName(pvc), newPVC); err != nil { - t.Fatalf("failed to get PVC after assume: %v", err) + if err := verifyObj(cache, keyOf(obj), newObj); err != nil { + t.Fatalf("failed to get after assume: %v", err) } - // Add old PVC - informer.add(pvc) - if err := verifyPVC(cache, getPVCName(pvc), newPVC); err != nil { - t.Fatalf("failed to get PVC after old PVC added: %v", err) + // Add old + informer.add(obj) + if err := verifyObj(cache, keyOf(obj), newObj); err != nil { + t.Fatalf("failed to get after old added: %v", err) } } func TestDelayedInformerEvent(t *testing.T) { - informer, cache := newTestPVCCache(t) + informer, cache := newTestCache(t) - pvcName := "test-pvc0" - pvcNamespace := "test-ns" - - pvc1 := makeClaim(pvcName, "1", pvcNamespace) - pvc2 := makeClaim(pvcName, "2", pvcNamespace) + obj1 := makeObj("test-pvc0", "1", "test-ns") + obj2 := makeObj("test-pvc0", "2", "test-ns") // Only add indexer, simulating delayed informer event - if err := informer.indexer.Add(pvc2); err != nil { - t.Fatalf("failed to add PVC: %v", err) + if err := informer.indexer.Add(obj2); err != nil { + t.Fatalf("failed to add: %v", err) } - newPVC := pvc2.DeepCopy() - newPVC.Annotations[volume.AnnSelectedNode] = "test-node" - if err := cache.Assume(newPVC); err != nil { - t.Fatalf("failed to assume PVC: %v", err) + newObj := obj2.DeepCopy() + newObj.Annotations[volume.AnnSelectedNode] = "test-node" + if err := cache.Assume(newObj); err != nil { + t.Fatalf("failed to assume: %v", err) } // Send the delayed event - informer.handler.OnAdd(pvc1, false) - informer.handler.OnDelete(pvc1) - informer.handler.OnAdd(pvc2, false) + informer.handler.OnAdd(obj1, false) + informer.handler.OnDelete(obj1) + informer.handler.OnAdd(obj2, false) // Expect assumed version not overwritten - if err := verifyPVC(cache, getPVCName(newPVC), newPVC); err != nil { - t.Fatalf("failed to get PVC after assume: %v", err) + if err := verifyObj(cache, keyOf(newObj), newObj); err != nil { + t.Fatalf("failed to get after assume: %v", err) } }