fix: correct bugs in values handling

Author: matteogastaldello

internal/restResources/support.go

@@ -122,7 +122,9 @@ func processFields(callInfo *CallInfo, fields map[string]interface{}, reqConfigu
 			}
 			reqConfiguration.Query[field] = stringVal
 		} else if callInfo.ReqParams.Body.Contains(field) {
-			mapBody[field] = value
+			if mapBody[field] == nil {
+				mapBody[field] = value
+			}
 		}
 	}
 }
@@ -134,11 +136,11 @@ func isCRUpdated(mg *unstructured.Unstructured, rm map[string]interface{}) (bool
 		return false, fmt.Errorf("error getting spec fields: %w", err)
 	}
 
-	return compareExisting(m, rm), nil
+	return compareExisting(m, rm)
 }
 
 // compareExisting recursively compares fields between two maps and logs differences.
-func compareExisting(mg map[string]interface{}, rm map[string]interface{}, path ...string) bool {
+func compareExisting(mg map[string]interface{}, rm map[string]interface{}, path ...string) (bool, error) {
 	for key, value := range mg {
 		currentPath := append(path, key)
 		pathStr := fmt.Sprintf("%v", currentPath)
@@ -148,63 +150,81 @@ func compareExisting(mg map[string]interface{}, rm map[string]interface{}, path
 			continue
 		}
 
+		fmt.Println("Comparing", pathStr, value, rmValue)
+
+		if reflect.TypeOf(value).Kind() != reflect.TypeOf(rmValue).Kind() {
+			return false, fmt.Errorf("types differ at %s - %s is different from %s", pathStr, reflect.TypeOf(value).Kind(), reflect.TypeOf(rmValue).Kind())
+		}
+
 		switch reflect.TypeOf(value).Kind() {
 		case reflect.Map:
 			mgMap, ok1 := value.(map[string]interface{})
 			if !ok1 {
 				fmt.Printf("Type assertion failed for map at '%s'\n", pathStr)
-				continue
+				return false, fmt.Errorf("type assertion failed for map at %s", pathStr)
 			}
 			rmMap, ok2 := rmValue.(map[string]interface{})
 			if !ok2 {
 				fmt.Printf("Type assertion failed for map at '%s'\n", pathStr)
-				continue
+				return false, fmt.Errorf("type assertion failed for map at %s", pathStr)
 			}
-			if !compareExisting(mgMap, rmMap, currentPath...) {
+			ok, err := compareExisting(mgMap, rmMap, currentPath...)
+			if err != nil {
+				return false, err
+			}
+			if !ok {
 				fmt.Printf("Values differ at '%s'\n", pathStr)
-				return false
+				return false, nil
 			}
 		case reflect.Slice:
 			valueSlice, ok1 := value.([]interface{})
 			if !ok1 || reflect.TypeOf(rmValue).Kind() != reflect.Slice {
 				fmt.Printf("Values are not both slices or type assertion failed at '%s'\n", pathStr)
-				continue
+				return false, fmt.Errorf("values are not both slices or type assertion failed at %s", pathStr)
 			}
 			rmSlice, ok2 := rmValue.([]interface{})
 			if !ok2 {
 				fmt.Printf("Type assertion failed for slice at '%s'\n", pathStr)
-				continue
+				return false, fmt.Errorf("type assertion failed for slice at %s", pathStr)
 			}
 			for i, v := range valueSlice {
 				if reflect.TypeOf(v).Kind() == reflect.Map {
 					mgMap, ok1 := v.(map[string]interface{})
 					if !ok1 {
 						fmt.Printf("Type assertion failed for map at '%s'\n", pathStr)
-						continue
+						return false, fmt.Errorf("type assertion failed for map at %s", pathStr)
 					}
 					rmMap, ok2 := rmSlice[i].(map[string]interface{})
 					if !ok2 {
 						fmt.Printf("Type assertion failed for map at '%s'\n", pathStr)
-						continue
+						return false, fmt.Errorf("type assertion failed for map at %s", pathStr)
+					}
+					ok, err := compareExisting(mgMap, rmMap, currentPath...)
+					if err != nil {
+						return false, err
 					}
-					if !compareExisting(mgMap, rmMap, currentPath...) {
+					if !ok {
 						fmt.Printf("Values differ at '%s'\n", pathStr)
-						return false
+						return false, nil
 					}
 				} else if v != rmSlice[i] {
 					fmt.Printf("Values differ at '%s'\n", pathStr)
-					return false
+					return false, nil
 				}
 			}
 		default:
-			if !compareAny(value, rmValue) {
+			ok, err := compareAny(value, rmValue)
+			if err != nil {
+				return false, err
+			}
+			if !ok {
 				fmt.Printf("Values differ at '%s' %s %s\n", pathStr, value, rmValue)
-				return false
+				return false, nil
 			}
 		}
 	}
 
-	return true
+	return true, nil
 }
 func numberCaster(value interface{}) int64 {
 	switch v := value.(type) {
@@ -237,23 +257,35 @@ func numberCaster(value interface{}) int64 {
 	}
 }
 
-func compareAny(a any, b any) bool {
+func compareAny(a any, b any) (bool, error) {
 	//if is number compare as number
 	switch a.(type) {
 	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64:
 		ia := numberCaster(a)
 		ib := numberCaster(b)
-		return ia == ib
+		return ia == ib, nil
 	case string:
-		sa := a.(string)
-		sb := b.(string)
-		return sa == sb
+		sa, ok := a.(string)
+		if !ok {
+			return false, fmt.Errorf("Type assertion failed - to string: %v", a)
+		}
+		sb, ok := b.(string)
+		if !ok {
+			return false, fmt.Errorf("Type assertion failed - to string: %v", b)
+		}
+		return sa == sb, nil
 	case bool:
-		ba := a.(bool)
-		bb := b.(bool)
-		return ba == bb
+		ba, ok := a.(bool)
+		if !ok {
+			return false, fmt.Errorf("Type assertion failed - to bool: %v", a)
+		}
+		bb, ok := b.(bool)
+		if !ok {
+			return false, fmt.Errorf("Type assertion failed - to bool: %v", b)
+		}
+		return ba == bb, nil
 	default:
-		return reflect.DeepEqual(a, b)
+		return reflect.DeepEqual(a, b), nil
 	}
 }