feat(recipe): Add support for string in pathcheck (#142)

Signed-off-by: Amit Bhatt <[email protected]>

Author: amitbhatt818

pkg/recipe/path_check.go

@@ -203,12 +203,58 @@ func (pc *PathChecking) assertValueFloat64(obj *unstructured.Unstructured) (bool
 	return true, nil
 }
 
+func (pc *PathChecking) assertValueString(obj *unstructured.Unstructured) (bool, error) {
+	got, found, err := unstructured.NestedString(
+		obj.UnstructuredContent(),
+		strings.Split(pc.PathCheck.Path, ".")...,
+	)
+	if err != nil {
+		return false, err
+	}
+	if !found {
+		return false, errors.Errorf(
+			"PathCheck failed: Path %q not found: TaskName %s",
+			pc.PathCheck.Path,
+			pc.TaskName,
+		)
+	}
+	val := pc.PathCheck.Value
+	expected, ok := val.(string)
+	if !ok {
+		return false, errors.Errorf(
+			"PathCheck failed: Value %v is of type %T, expected string: TaskName %s",
+			val,
+			val,
+			pc.TaskName,
+		)
+	}
+	pc.result.Verbose = fmt.Sprintf(
+		"Expected value %s got %s",
+		expected,
+		got,
+	)
+	if pc.retryIfValueEquals && got == expected {
+		return false, nil
+	}
+	if pc.retryIfValueNotEquals && got != expected {
+		return false, nil
+	}
+	// returning true will no longer retry
+	return true, nil
+}
+
 func (pc *PathChecking) assertValue(obj *unstructured.Unstructured) (bool, error) {
-	if pc.PathCheck.DataType == types.PathValueDataTypeInt64 {
+
+	switch pc.PathCheck.DataType {
+	case types.PathValueDataTypeInt64:
 		return pc.assertValueInt64(obj)
+
+	case types.PathValueDataTypeFloat64:
+		return pc.assertValueFloat64(obj)
+
+	default:
+		return pc.assertValueString(obj)
 	}
-	// currently float & int64 are supported data types
-	return pc.assertValueFloat64(obj)
 }
 
 func (pc *PathChecking) assertPath(obj *unstructured.Unstructured) (bool, error) {

pkg/recipe/path_check_test.go

@@ -0,0 +1,128 @@
+package recipe
+
+import (
+	"testing"
+
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	types "mayadata.io/d-operators/types/recipe"
+)
+
+func TestPathCheckingAssertValueString(t *testing.T) {
+	var tests = map[string]struct {
+		State                 *unstructured.Unstructured
+		TaskName              string
+		PathCheck             string
+		Path                  string
+		Value                 string
+		retryIfValueEquals    bool
+		retryIfValueNotEquals bool
+		IsError               bool
+		ExpectedAssert        bool
+	}{
+		"assert ipaddress None == None": {
+			State: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "v1",
+					"kind":       "Service",
+					"metadata": map[string]interface{}{
+						"name":      "test",
+						"namespace": "default",
+					},
+					"spec": map[string]interface{}{
+						"ipAddress": "None",
+					},
+				},
+			},
+			Path:                  "spec.ipAddress",
+			Value:                 "None",
+			retryIfValueNotEquals: true,
+			ExpectedAssert:        true,
+		},
+		"assert ipaddress ip != 12.123.12.11": {
+			State: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "v1",
+					"kind":       "Service",
+					"metadata": map[string]interface{}{
+						"name":      "test",
+						"namespace": "default",
+					},
+					"spec": map[string]interface{}{
+						"ipAddress": "12.123.12.11",
+					},
+				},
+			},
+			Path:               "spec.ipAddress",
+			Value:              "None",
+			retryIfValueEquals: true,
+			ExpectedAssert:     true,
+		},
+		"assert ipaddress ip != ": {
+			State: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "v1",
+					"kind":       "Service",
+					"metadata": map[string]interface{}{
+						"name":      "test",
+						"namespace": "default",
+					},
+					"spec": map[string]interface{}{
+						"ipAddress": "12.123.12.11",
+					},
+				},
+			},
+			Path:               "spec.ipAddress",
+			Value:              "",
+			retryIfValueEquals: true,
+			ExpectedAssert:     true,
+		},
+		"assert ipaddress Nil != None": {
+			State: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "v1",
+					"kind":       "Service",
+					"metadata": map[string]interface{}{
+						"name":      "test",
+						"namespace": "default",
+					},
+					"spec": map[string]interface{}{
+						"ipAddress": "None",
+					},
+				},
+			},
+			Path:                  "spec.ipAddress",
+			Value:                 "Nil",
+			retryIfValueNotEquals: true,
+			ExpectedAssert:        false,
+		},
+	}
+	for scenario, tObj := range tests {
+		scenario := scenario
+		tObj := tObj
+		t.Run(scenario, func(t *testing.T) {
+			pc := &PathChecking{
+				PathCheck: types.PathCheck{
+					Path:  tObj.Path,
+					Value: tObj.Value,
+				},
+				retryIfValueEquals:    tObj.retryIfValueEquals,
+				retryIfValueNotEquals: tObj.retryIfValueNotEquals,
+				result:                &types.PathCheckResult{},
+			}
+			got, err := pc.assertValueString(tObj.State)
+			if tObj.IsError && err == nil {
+				t.Fatalf("Expected error got none")
+			}
+			if !tObj.IsError && err != nil {
+				t.Fatalf("Expected no error got %s", err.Error())
+			}
+			if tObj.IsError {
+				return
+			}
+			if got != tObj.ExpectedAssert {
+				t.Fatalf("Expected assert = %t got %t", tObj.ExpectedAssert, got)
+			}
+
+		})
+	}
+}

types/recipe/patch_check.go

@@ -84,6 +84,10 @@ const (
 	// PathValueDataTypeFloat64 expects path's value with float64
 	// as its data type
 	PathValueDataTypeFloat64 PathValueDataType = "float64"
+
+	// PathValueDataTypeString expects path's value with string
+	// as its data type
+	PathValueDataTypeString PathValueDataType = "string"
 )
 
 // PathCheck verifies expected field value against