Drop WatchSequenceEventVerifier from configmap lifecycle test

Collecting events in a certain order and then verifying the order in
which they were collected feels redundant.

Author: spiffxp

test/e2e/common/configmap.go

@@ -24,11 +24,11 @@ import (
 
 	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/uuid"
 	watch "k8s.io/apimachinery/pkg/watch"
 	"k8s.io/client-go/dynamic"
+	"k8s.io/client-go/tools/cache"
 	watchtools "k8s.io/client-go/tools/watch"
 	"k8s.io/kubernetes/test/e2e/framework"
 	imageutils "k8s.io/kubernetes/test/utils/image"
@@ -172,12 +172,6 @@ var _ = ginkgo.Describe("[sig-node] ConfigMap", func() {
 		testNamespaceName := f.Namespace.Name
 		testConfigMapName := "test-configmap" + string(uuid.NewUUID())
 
-		configMapResource := schema.GroupVersionResource{Group: "", Version: "v1", Resource: "configmaps"}
-		expectedWatchEvents := []watch.Event{
-			{Type: watch.Added},
-			{Type: watch.Modified},
-			{Type: watch.Deleted},
-		}
 		testConfigMap := v1.ConfigMap{
 			ObjectMeta: metav1.ObjectMeta{
 				Name: testConfigMapName,
@@ -190,103 +184,86 @@ var _ = ginkgo.Describe("[sig-node] ConfigMap", func() {
 			},
 		}
 
-		framework.WatchEventSequenceVerifier(context.TODO(), dc, configMapResource, testNamespaceName, testConfigMapName, metav1.ListOptions{LabelSelector: "test-configmap-static=true"}, expectedWatchEvents, func(retryWatcher *watchtools.RetryWatcher) (actualWatchEvents []watch.Event) {
-			ginkgo.By("creating a ConfigMap")
-			_, err := f.ClientSet.CoreV1().ConfigMaps(testNamespaceName).Create(context.TODO(), &testConfigMap, metav1.CreateOptions{})
-			framework.ExpectNoError(err, "failed to create ConfigMap")
-			eventFound := false
-			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-			defer cancel()
-			_, err = framework.WatchUntilWithoutRetry(ctx, retryWatcher, func(watchEvent watch.Event) (bool, error) {
-				if watchEvent.Type != watch.Added {
-					return false, nil
-				}
-				actualWatchEvents = append(actualWatchEvents, watchEvent)
-				eventFound = true
-				return true, nil
-			})
-			framework.ExpectNoError(err, "Wait until condition with watch events should not return an error")
-			framework.ExpectEqual(eventFound, true, "failed to find ConfigMap %v event", watch.Added)
-
-			configMapPatchPayload, err := json.Marshal(v1.ConfigMap{
-				ObjectMeta: metav1.ObjectMeta{
-					Labels: map[string]string{
-						"test-configmap": "patched",
-					},
-				},
-				Data: map[string]string{
-					"valueName": "value1",
+		w := &cache.ListWatch{
+			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
+				options.LabelSelector = "test-configmap-static=true"
+				return f.ClientSet.CoreV1().ConfigMaps(testNamespaceName).Watch(context.TODO(), options)
+			},
+		}
+		cml, err := f.ClientSet.CoreV1().ConfigMaps(testNamespaceName).List(context.TODO(), metav1.ListOptions{LabelSelector: "test-configmap-static=true"})
+		framework.ExpectNoError(err)
+		retryWatcher, err := watchtools.NewRetryWatcher(cml.ResourceVersion, w)
+
+		ginkgo.By("creating a ConfigMap")
+		_, err = f.ClientSet.CoreV1().ConfigMaps(testNamespaceName).Create(context.TODO(), &testConfigMap, metav1.CreateOptions{})
+		framework.ExpectNoError(err, "failed to create ConfigMap")
+
+		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+		defer cancel()
+		_, err = framework.WatchUntilWithoutRetry(ctx, retryWatcher, func(watchEvent watch.Event) (bool, error) {
+			return watchEvent.Type == watch.Added, nil
+		})
+		framework.ExpectNoError(err, "failed to see a watch.Added event for the configmap we created")
+
+		configMapPatchPayload, err := json.Marshal(v1.ConfigMap{
+			ObjectMeta: metav1.ObjectMeta{
+				Labels: map[string]string{
+					"test-configmap": "patched",
 				},
-			})
-			framework.ExpectNoError(err, "failed to marshal patch data")
-
-			ginkgo.By("patching the ConfigMap")
-			_, err = f.ClientSet.CoreV1().ConfigMaps(testNamespaceName).Patch(context.TODO(), testConfigMapName, types.StrategicMergePatchType, []byte(configMapPatchPayload), metav1.PatchOptions{})
-			framework.ExpectNoError(err, "failed to patch ConfigMap")
-			ginkgo.By("waiting for the ConfigMap to be modified")
-			eventFound = false
-			ctx, cancel = context.WithTimeout(context.Background(), 30*time.Second)
-			defer cancel()
-			_, err = framework.WatchUntilWithoutRetry(ctx, retryWatcher, func(watchEvent watch.Event) (bool, error) {
-				if watchEvent.Type != watch.Modified {
-					return false, nil
-				}
-				actualWatchEvents = append(actualWatchEvents, watchEvent)
-				eventFound = true
-				return true, nil
-			})
-			framework.ExpectNoError(err, "Wait until condition with watch events should not return an error")
-			framework.ExpectEqual(eventFound, true, "failed to find ConfigMap %v event", watch.Modified)
-
-			ginkgo.By("fetching the ConfigMap")
-			configMap, err := f.ClientSet.CoreV1().ConfigMaps(testNamespaceName).Get(context.TODO(), testConfigMapName, metav1.GetOptions{})
-			framework.ExpectNoError(err, "failed to get ConfigMap")
-			framework.ExpectEqual(configMap.Data["valueName"], "value1", "failed to patch ConfigMap")
-			framework.ExpectEqual(configMap.Labels["test-configmap"], "patched", "failed to patch ConfigMap")
-
-			ginkgo.By("listing all ConfigMaps in all namespaces")
-			configMapList, err := f.ClientSet.CoreV1().ConfigMaps("").List(context.TODO(), metav1.ListOptions{
-				LabelSelector: "test-configmap-static=true",
-			})
-			framework.ExpectNoError(err, "failed to list ConfigMaps with LabelSelector")
-			framework.ExpectNotEqual(len(configMapList.Items), 0, "no ConfigMaps found in ConfigMap list")
-			testConfigMapFound := false
-			for _, cm := range configMapList.Items {
-				if cm.ObjectMeta.Name == testConfigMapName &&
-					cm.ObjectMeta.Namespace == testNamespaceName &&
-					cm.ObjectMeta.Labels["test-configmap-static"] == "true" &&
-					cm.Data["valueName"] == "value1" {
-					testConfigMapFound = true
-					break
-				}
+			},
+			Data: map[string]string{
+				"valueName": "value1",
+			},
+		})
+		framework.ExpectNoError(err, "failed to marshal patch data")
+
+		ginkgo.By("patching the ConfigMap")
+		_, err = f.ClientSet.CoreV1().ConfigMaps(testNamespaceName).Patch(context.TODO(), testConfigMapName, types.StrategicMergePatchType, []byte(configMapPatchPayload), metav1.PatchOptions{})
+		framework.ExpectNoError(err, "failed to patch ConfigMap")
+		ginkgo.By("waiting for the ConfigMap to be modified")
+		ctx, cancel = context.WithTimeout(context.Background(), 30*time.Second)
+		defer cancel()
+		_, err = framework.WatchUntilWithoutRetry(ctx, retryWatcher, func(watchEvent watch.Event) (bool, error) {
+			return watchEvent.Type == watch.Modified, nil
+		})
+		framework.ExpectNoError(err, "failed to see a watch.Modified event for the configmap we patched")
+
+		ginkgo.By("fetching the ConfigMap")
+		configMap, err := f.ClientSet.CoreV1().ConfigMaps(testNamespaceName).Get(context.TODO(), testConfigMapName, metav1.GetOptions{})
+		framework.ExpectNoError(err, "failed to get ConfigMap")
+		framework.ExpectEqual(configMap.Data["valueName"], "value1", "failed to patch ConfigMap")
+		framework.ExpectEqual(configMap.Labels["test-configmap"], "patched", "failed to patch ConfigMap")
+
+		ginkgo.By("listing all ConfigMaps in all namespaces")
+		configMapList, err := f.ClientSet.CoreV1().ConfigMaps("").List(context.TODO(), metav1.ListOptions{
+			LabelSelector: "test-configmap-static=true",
+		})
+		framework.ExpectNoError(err, "failed to list ConfigMaps with LabelSelector")
+		framework.ExpectNotEqual(len(configMapList.Items), 0, "no ConfigMaps found in ConfigMap list")
+		testConfigMapFound := false
+		for _, cm := range configMapList.Items {
+			if cm.ObjectMeta.Name == testConfigMapName &&
+				cm.ObjectMeta.Namespace == testNamespaceName &&
+				cm.ObjectMeta.Labels["test-configmap-static"] == "true" &&
+				cm.Data["valueName"] == "value1" {
+				testConfigMapFound = true
+				break
 			}
-			framework.ExpectEqual(testConfigMapFound, true, "failed to find ConfigMap in list")
-
-			ginkgo.By("deleting the ConfigMap by a collection")
-			err = f.ClientSet.CoreV1().ConfigMaps(testNamespaceName).DeleteCollection(context.TODO(), metav1.DeleteOptions{}, metav1.ListOptions{
-				LabelSelector: "test-configmap-static=true",
-			})
-			framework.ExpectNoError(err, "failed to delete ConfigMap collection with LabelSelector")
-			ginkgo.By("waiting for the ConfigMap to be deleted")
-			eventFound = false
-			ctx, cancel = context.WithTimeout(context.Background(), 30*time.Second)
-			defer cancel()
-			_, err = framework.WatchUntilWithoutRetry(ctx, retryWatcher, func(watchEvent watch.Event) (bool, error) {
-				if watchEvent.Type != watch.Deleted {
-					return false, nil
-				}
-				actualWatchEvents = append(actualWatchEvents, watchEvent)
-				eventFound = true
-				return true, nil
-			})
-			framework.ExpectNoError(err, "Wait until condition with watch events should not return an error")
-			framework.ExpectEqual(eventFound, true, "failed to find ConfigMap %v event", watch.Deleted)
-
-			return actualWatchEvents
-		}, func() (err error) {
-			_ = f.ClientSet.CoreV1().ConfigMaps(testNamespaceName).DeleteCollection(context.TODO(), metav1.DeleteOptions{}, metav1.ListOptions{LabelSelector: "test-configmap-static=true"})
-			return err
+		}
+		framework.ExpectEqual(testConfigMapFound, true, "failed to find ConfigMap in list")
+
+		ginkgo.By("deleting the ConfigMap by a collection")
+		err = f.ClientSet.CoreV1().ConfigMaps(testNamespaceName).DeleteCollection(context.TODO(), metav1.DeleteOptions{}, metav1.ListOptions{
+			LabelSelector: "test-configmap-static=true",
+		})
+		framework.ExpectNoError(err, "failed to delete ConfigMap collection with LabelSelector")
+		ginkgo.By("waiting for the ConfigMap to be deleted")
+		ctx, cancel = context.WithTimeout(context.Background(), 30*time.Second)
+		defer cancel()
+		_, err = framework.WatchUntilWithoutRetry(ctx, retryWatcher, func(watchEvent watch.Event) (bool, error) {
+			return watchEvent.Type == watch.Deleted, nil
 		})
+		framework.ExpectNoError(err, "fasiled to observe a watch.Deleted event for the ConfigMap we deleted")
 	})
 })