feat: add converge to field step which improves upon converge to selector

internal/util/util.go

@@ -21,6 +21,7 @@
 	"path/filepath"
 	"reflect"
 	"runtime"
+	"strconv"
 	"strings"
 	"time"
 
@@ -133,3 +134,30 @@
 	s, _ := json.MarshalIndent(st, "", "\t")
 	return string(s)
 }
+
+func ExtractField(data any, path []string) (any, error) {
+	if len(path) == 0 || data == nil {
+		return data, nil
+	}
+
+	currKey := path[0]
+
+	maybeArr := strings.Split(currKey, "[")
+	if len(maybeArr) >= 2 {
+		indexStr := strings.TrimSuffix(maybeArr[1], "]")
+		i, err := strconv.Atoi(indexStr)
+		if err != nil {
+			return nil, err
+		}
+		arr := data.(map[string]any)[maybeArr[0]].([]any)
+		return ExtractField(arr[i], path[1:])
+	}
+
+	for key, val := range data.(map[string]any) {
+		if key == currKey {
+			return ExtractField(val, path[1:])
+		}
+	}
+
+	return nil, nil
+}

kubedog.go

@@ -53,6 +53,7 @@
 	kdt.scenario.Step(`^(?:I )?(create|submit|delete|update|upsert) (?:the )?resource (\S+) in (?:the )?([^"]*) namespace, the operation should (succeed|fail)$`, kdt.KubeClientSet.ResourceOperationWithResultInNamespace)
 	kdt.scenario.Step(`^(?:the )?resource ([^"]*) should be (created|deleted)$`, kdt.KubeClientSet.ResourceShouldBe)
 	kdt.scenario.Step(`^(?:the )?resource (\S+) (?:should )?converge to selector (\S+)$`, kdt.KubeClientSet.ResourceShouldConvergeToSelector)
+	kdt.scenario.Step(`^(?:the )?resource (\S+) (?:should )?converge to field (\S+)$`, kdt.KubeClientSet.ResourceShouldConvergeToField)
 	kdt.scenario.Step(`^(?:the )?resource ([^"]*) condition ([^"]*) should be ([^"]*)$`, kdt.KubeClientSet.ResourceConditionShouldBe)
 	kdt.scenario.Step(`^(?:I )?update (?:the )?resource ([^"]*) with ([^"]*) set to ([^"]*)$`, kdt.KubeClientSet.UpdateResourceWithField)
 	kdt.scenario.Step(`^(?:I )?verify InstanceGroups (?:are )?in "ready" state$`, kdt.KubeClientSet.VerifyInstanceGroups)

pkg/kube/kube.go

@@ -190,6 +190,14 @@
 	return unstruct.ResourceShouldConvergeToSelector(kc.DynamicInterface, resource, kc.getWaiterConfig(), selector)
 }
 
+func (kc *ClientSet) ResourceShouldConvergeToField(resourceFileName, selector string) error {
+	resource, err := unstruct.GetResource(kc.getDiscoveryClient(), kc.config.templateArguments, kc.getResourcePath(resourceFileName))
+	if err != nil {
+		return err
+	}
+	return unstruct.ResourceShouldConvergeToField(kc.DynamicInterface, resource, kc.getWaiterConfig(), selector)
+}
+
 func (kc *ClientSet) ResourceConditionShouldBe(resourceFileName, conditionType, conditionValue string) error {
 	resource, err := unstruct.GetResource(kc.getDiscoveryClient(), kc.config.templateArguments, kc.getResourcePath(resourceFileName))
 	if err != nil {

pkg/kube/unstructured/test/files/resource.yaml

@@ -8,4 +8,11 @@ metadata:
 status:
   conditions:
     - type: someConditionType
-      status: "True"
+      status: "True"
+  replicaCount: 2
+spec:
+  template:
+    containers:
+    - name: someContainer
+      image: someImage
+      version: 1.0.0

pkg/kube/unstructured/unstructured.go

@@ -19,6 +19,7 @@
 	"fmt"
 	"os"
 	"path/filepath"
+	"reflect"
 	"strconv"
 	"strings"
 	"time"
@@ -195,6 +196,64 @@
 	}
 }
 
+func ResourceShouldConvergeToField(dynamicClient dynamic.Interface, resource unstructuredResource, w common.WaiterConfig, selector string) error {
+	var counter int
+
+	if err := validateDynamicClient(dynamicClient); err != nil {
+		return err
+	}
+
+	split := util.DeleteEmpty(strings.Split(selector, "="))
+	if len(split) != 2 {
+		return errors.Errorf("Selector '%s' should meet format '<key>=<value>'", selector)
+	}
+
+	key := split[0]
+	value := split[1]
+
+	keySlice := util.DeleteEmpty(strings.Split(key, "."))
+	if len(keySlice) < 1 {
+		return errors.Errorf("Found empty 'key' in selector '%s' of form '<key>=<value>'", selector)
+	}
+
+	gvr, unstruct := resource.GVR, resource.Resource
+
+	for {
+		if counter >= w.GetTries() {
+			return errors.New("waiter timed out waiting for resource")
+		}
+		log.Infof("waiting for resource %v/%v to converge to %v=%v", unstruct.GetNamespace(), unstruct.GetName(), key, value)
+		retResource, err := dynamicClient.Resource(gvr.Resource).Namespace(unstruct.GetNamespace()).Get(context.Background(), unstruct.GetName(), metav1.GetOptions{})
+		if err != nil {
+			return err
+		}
+
+		val, err := util.ExtractField(retResource.UnstructuredContent(), keySlice)
+		if err != nil {
+			return err
+		}
+		var convertedValue any
+		switch val.(type) {
+		case int, int64:
+			convertedValue, err = strconv.ParseInt(value, 10, 64)
+			if err != nil {
+				return err
+			}
+		case string:
+			convertedValue = value
+		default:
+			return errors.New("unknown type")
+		}
+		if reflect.DeepEqual(val, convertedValue) {
+			break
+		}
+		counter++
+		time.Sleep(w.GetInterval())
+	}
+
+	return nil
+}
+
 func ResourceShouldConvergeToSelector(dynamicClient dynamic.Interface, resource unstructuredResource, w common.WaiterConfig, selector string) error {
 	var counter int
 

pkg/kube/unstructured/unstructured_test.go

@@ -519,6 +519,81 @@ func TestResourceShouldConvergeToSelector(t *testing.T) {
 	}
 }
 
+func TestResourceShouldConvergeToField(t *testing.T) {
+	type args struct {
+		dynamicClient dynamic.Interface
+		resource      unstructuredResource
+		w             common.WaiterConfig
+		selector      string
+	}
+	resource := getResourceFromYaml(t, getFilePath("resource.yaml"))
+	labelKey, labelValue := getOneLabel(t, *resource.Resource)
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name: "Positive Test",
+			args: args{
+				dynamicClient: newFakeDynamicClientWithResource(resource),
+				resource:      resource,
+				selector:      ".metadata.labels." + labelKey + "=" + labelValue,
+			},
+		},
+		{
+			name: "Positive Test: array",
+			args: args{
+				dynamicClient: newFakeDynamicClientWithResource(resource),
+				resource:      resource,
+				selector:      ".spec.template.containers[0].image=someImage",
+			},
+		},
+		{
+			name: "Positive Test: non-string value",
+			args: args{
+				dynamicClient: newFakeDynamicClientWithResource(resource),
+				resource:      resource,
+				selector:      ".status.replicaCount=2",
+			},
+		},
+		{
+			name: "Positive Test: array and non-string value",
+			args: args{
+				dynamicClient: newFakeDynamicClientWithResource(resource),
+				resource:      resource,
+				selector:      ".spec.template.containers[0].version=1.0.0",
+			},
+		},
+		{
+			name: "Negative Test: invalid selector",
+			args: args{
+				dynamicClient: newFakeDynamicClientWithResource(resource),
+				resource:      resource,
+				selector:      ".invalid.selector.",
+			},
+			wantErr: true,
+		},
+		{
+			name: "Negative Test: invalid key",
+			args: args{
+				dynamicClient: newFakeDynamicClientWithResource(resource),
+				resource:      resource,
+				selector:      ".=invalid-key",
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.args.w = common.NewWaiterConfig(1, time.Second)
+			if err := ResourceShouldConvergeToField(tt.args.dynamicClient, tt.args.resource, tt.args.w, tt.args.selector); (err != nil) != tt.wantErr {
+				t.Errorf("ResourceShouldConvergeToSelector() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
 func TestResourceConditionShouldBe(t *testing.T) {
 	type args struct {
 		dynamicClient  dynamic.Interface