Correcting lint issues and adding unit tests

Signed-off-by: Annaraya Narasagond <[email protected]>
Signed-off-by: Annaraya Narasagond <[email protected]> Annaraya Narasagond <[email protected]>

internal/controller/util/json_util.go

@@ -39,7 +39,7 @@ func EvaluateCheckHook(client client.Client, hook *kubeobjects.HookSpec, log log
 			return false, err
 		}
 
-		return evaluateCheckHookExp(hook.Chk.Condition, resource)
+		return EvaluateCheckHookExp(hook.Chk.Condition, resource)
 	case "deployment":
 		// handle deployment type
 		resource := &appsv1.Deployment{}
@@ -49,7 +49,7 @@ func EvaluateCheckHook(client client.Client, hook *kubeobjects.HookSpec, log log
 			return false, err
 		}
 
-		return evaluateCheckHookExp(hook.Chk.Condition, resource)
+		return EvaluateCheckHookExp(hook.Chk.Condition, resource)
 	case "statefulset":
 		// handle statefulset type
 		resource := &appsv1.StatefulSet{}
@@ -59,7 +59,7 @@ func EvaluateCheckHook(client client.Client, hook *kubeobjects.HookSpec, log log
 			return false, err
 		}
 
-		return evaluateCheckHookExp(hook.Chk.Condition, resource)
+		return EvaluateCheckHookExp(hook.Chk.Condition, resource)
 	}
 
 	return false, nil
@@ -104,7 +104,7 @@ func getTimeoutValue(hook *kubeobjects.HookSpec) int {
 	return defaultTimeoutValue
 }
 
-func evaluateCheckHookExp(booleanExpression string, jsonData interface{}) (bool, error) {
+func EvaluateCheckHookExp(booleanExpression string, jsonData interface{}) (bool, error) {
 	op, jsonPaths, err := parseBooleanExpression(booleanExpression)
 	if err != nil {
 		return false, fmt.Errorf("failed to parse boolean expression: %w", err)
@@ -197,6 +197,36 @@ func compareBool(a, b bool, operator string) (bool, error) {
 	}
 }
 
+func compareString(a, b, operator string) (bool, error) {
+	switch operator {
+	case "==":
+		return a == b, nil
+	case "!=":
+		return a != b, nil
+	default:
+		return false, fmt.Errorf("unknown operator: %s", operator)
+	}
+}
+
+func compareFloat(a, b float64, operator string) (bool, error) {
+	switch operator {
+	case "==":
+		return a == b, nil
+	case "!=":
+		return a != b, nil
+	case "<":
+		return a < b, nil
+	case ">":
+		return a > b, nil
+	case "<=":
+		return a <= b, nil
+	case ">=":
+		return a >= b, nil
+	default:
+		return false, fmt.Errorf("unknown operator: %s", operator)
+	}
+}
+
 func compareValues(val1, val2 interface{}, operator string) (bool, error) {
 	switch v1 := val1.(type) {
 	case float64:
@@ -205,44 +235,21 @@ func compareValues(val1, val2 interface{}, operator string) (bool, error) {
 			return false, fmt.Errorf("mismatched types")
 		}
 
-		switch operator {
-		case "==":
-			return v1 == v2, nil
-		case "!=":
-			return v1 != v2, nil
-		case "<":
-			return v1 < v2, nil
-		case ">":
-			return v1 > v2, nil
-		case "<=":
-			return v1 <= v2, nil
-		case ">=":
-			return v1 >= v2, nil
-		}
+		return compareFloat(v1, v2, operator)
 	case string:
 		v2, ok := val2.(string)
 		if !ok {
 			return false, fmt.Errorf("mismatched types")
 		}
 
-		switch operator {
-		case "==":
-			return v1 == v2, nil
-		case "!=":
-			return v1 != v2, nil
-		}
+		return compareString(v1, v2, operator)
 	case bool:
 		v2, ok := val2.(bool)
 		if !ok {
 			return false, fmt.Errorf("mismatched types")
 		}
 
-		switch operator {
-		case "==":
-			return v1 == v2, nil
-		case "!=":
-			return v1 != v2, nil
-		}
+		return compareBool(v1, v2, operator)
 	}
 
 	return false, fmt.Errorf("unsupported type or operator")
@@ -281,16 +288,16 @@ func parseBooleanExpression(booleanExpression string) (op string, jsonPaths []st
 		jsonPaths = trimLeadingTrailingWhiteSpace(exprs)
 
 		if len(exprs) == 2 &&
-			isValidJSONPathExpression(jsonPaths[0]) &&
-			isValidJSONPathExpression(jsonPaths[1]) {
+			IsValidJSONPathExpression(jsonPaths[0]) &&
+			IsValidJSONPathExpression(jsonPaths[1]) {
 			return op, jsonPaths, nil
 		}
 	}
 
 	return "", []string{}, fmt.Errorf("unable to parse boolean expression %v", booleanExpression)
 }
 
-func isValidJSONPathExpression(expr string) bool {
+func IsValidJSONPathExpression(expr string) bool {
 	jp := jsonpath.New("validator").AllowMissingKeys(true)
 
 	err := jp.Parse(expr)

internal/controller/util/json_util_test.go

@@ -0,0 +1,199 @@
+package util_test
+
+import (
+	"encoding/json"
+	"strconv"
+	"testing"
+
+	"github.com/ramendr/ramen/internal/controller/util"
+)
+
+type testCases struct {
+	jsonPathExprs string
+	result        bool
+}
+
+var jsonText1 = []byte(`{
+    "kind": "Deployment",
+    "spec": {
+        "progressDeadlineSeconds": 600,
+        "replicas": 1,
+        "revisionHistoryLimit": 10
+    },
+    "status": {
+        "replicas": 1,
+        "conditions": [
+            {
+                "status": "True",
+                "type": "Progressing"
+            },
+            {
+                "status": "True",
+                "type": "Available"
+            }
+        ]
+    }
+    }`)
+
+var testCasesData = []testCases{
+	{
+		jsonPathExprs: "{$.status.conditions[0].status} == True",
+		result:        true,
+	},
+	{
+		jsonPathExprs: "{$.spec.replicas} == 1",
+		result:        true,
+	},
+	{
+		jsonPathExprs: "{$.status.conditions[0].status} == {True}",
+		result:        false,
+	},
+}
+
+func TestXYZ(t *testing.T) {
+	for i, tt := range testCasesData {
+		t.Run(strconv.Itoa(i), func(t *testing.T) {
+			var jsonData map[string]interface{}
+			err := json.Unmarshal(jsonText1, &jsonData)
+			if err != nil {
+				t.Error(err)
+			}
+			_, err = util.EvaluateCheckHookExp(tt.jsonPathExprs, jsonData)
+			if (err == nil) != tt.result {
+				t.Errorf("EvaluateCheckHook() = %v, want %v", err, tt.result)
+			}
+		})
+	}
+}
+
+func Test_isValidJsonPathExpression(t *testing.T) {
+	type args struct {
+		expr string
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{
+			name: "Simple expression",
+			args: args{
+				expr: "$.spec.replicas",
+			},
+			want: true,
+		},
+		{
+			name: "no $ at the start",
+			args: args{
+				expr: "{.spec.replicas}",
+			},
+			want: true,
+		},
+		{
+			name: "element in array",
+			args: args{
+				expr: "{$.status.conditions[0].status}",
+			},
+			want: true,
+		},
+		{
+			name: "spec 1",
+			args: args{
+				expr: "{$.status.readyReplicas}",
+			},
+			want: true,
+		},
+		{
+			name: "spec 2",
+			args: args{
+				expr: "{$.status.containerStatuses[0].ready}",
+			},
+			want: true,
+		},
+		{
+			name: "spec 3a",
+			args: args{
+				expr: "{True}",
+			},
+			want: false,
+		},
+		{
+			name: "spec 3b",
+			args: args{
+				expr: "{False}",
+			},
+			want: false,
+		},
+		{
+			name: "spec 3c",
+			args: args{
+				expr: "{true}",
+			},
+			want: true,
+		},
+		{
+			name: "spec 3d",
+			args: args{
+				expr: "{false}",
+			},
+			want: true,
+		},
+		{
+			name: "Spec 4",
+			args: args{
+				expr: "{$.spec.replicas}",
+			},
+			want: true,
+		},
+		{
+			name: "expression with == operator",
+			args: args{
+				expr: "$.store.book[?(@.price > 10)].title==$.store.book[0].title",
+			},
+			want: true,
+		},
+		{
+			name: "expression with > operator",
+			args: args{
+				expr: "$.store.book[?(@.author CONTAINS 'Smith')].price>20",
+			},
+			want: true,
+		},
+		{
+			name: "expression with >= operator",
+			args: args{
+				expr: "$.user.age>=$.minimum.age",
+			},
+			want: true,
+		},
+		{
+			name: "expression with < operator",
+			args: args{
+				expr: "$.user.age<$.maximum.age",
+			},
+			want: true,
+		},
+		{
+			name: "expression with <= operator",
+			args: args{
+				expr: "$.user.age<=$.maximum.age",
+			},
+			want: true,
+		},
+		{
+			name: "expression with != operator",
+			args: args{
+				expr: "$.user.age!=$.maximum.age",
+			},
+			want: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := util.IsValidJSONPathExpression(tt.args.expr); got != tt.want {
+				t.Errorf("isValidJsonPathExpression() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

internal/controller/vrg_kubeobjects.go

@@ -259,14 +259,12 @@ func (v *VRGInstance) kubeObjectsCaptureStartOrResume(
 					log1.Info("Check hook executed successfully", "check hook is ", hookName, " result is ", hookResult)
 				}
 
-				if !hookResult {
-					if shouldHookBeFailedOnError(&cg.Hook) {
-						// update error state
-						break
-					}
+				if !hookResult && shouldHookBeFailedOnError(&cg.Hook) {
 					// update error state
-					continue
+					break
 				}
+				// update error state
+				continue
 			}
 		} else {
 			requestsCompletedCount += v.kubeObjectsGroupCapture(
@@ -632,16 +630,16 @@ func (v *VRGInstance) kubeObjectsRecoveryStartOrResume(
 		log1 := log.WithValues("group", groupNumber, "name", rg.BackupName)
 
 		if rg.IsHook {
-			hookResult, err := util.EvaluateCheckHook(v.reconciler.Client, &rg.Hook, log1)
-			if err != nil {
-				log.Error(err, "error occurred during check hook ")
-			} else {
-				hookName := rg.Hook.Name + "/" + rg.Hook.Chk.Name
-				log1.Info("Check hook executed successfully", "check hook is ", hookName, " result is ", hookResult)
-			}
+			if rg.Hook.Type == "check" {
+				hookResult, err := util.EvaluateCheckHook(v.reconciler.Client, &rg.Hook, log1)
+				if err != nil {
+					log.Error(err, "error occurred during check hook ")
+				} else {
+					hookName := rg.Hook.Name + "/" + rg.Hook.Chk.Name
+					log1.Info("Check hook executed successfully", "check hook is ", hookName, " result is ", hookResult)
+				}
 
-			if !hookResult {
-				if shouldHookBeFailedOnError(&rg.Hook) {
+				if !hookResult && shouldHookBeFailedOnError(&rg.Hook) {
 					// update error state
 					break
 				}