fix <3

Author: Gnoale

internal/acctest/compare.go

@@ -1,22 +1,12 @@
 package acctest
 
 import (
-	"errors"
-	"fmt"
 	"net/url"
 	"reflect"
 	"sort"
 	"strings"
 )
 
-var (
-	ErrKeyIndex        = errors.New("key index not found")
-	ErrValueIndex      = errors.New("value index not found")
-	ErrNotComparable   = errors.New("not comparable")
-	supportedMapKeys   = []string{"key", "name"}
-	supportedMapValues = []string{"value", "values"}
-)
-
 // compareJSONFields is the entry point for comparing two interface values
 // handle string with special cases, map[string]interface{} and []interface{} or any other primitive type
 func compareJSONFields(requestValue, cassetteValue interface{}) bool {
@@ -201,115 +191,44 @@ func compareSlices(request, cassette []interface{}) bool {
 
 		return true
 	case map[string]interface{}:
-		// potential corner cases:
-		// - the maps have the same structure to identify key value pairs: we normalize and compare them
-		// - the maps have different structure: we recurse on compareJSONFields to individually compare them
-		requestMap, cassetteMap, err := normalizeMaps(request, cassette)
-		if err != nil {
-			for i, v := range request {
-				// remove keys that are not relevant for comparison
-				// like project_id, organization_id, etc.
-				for _, key := range BodyMatcherIgnore {
-					removeKeyRecursive(cassette[i].(map[string]interface{}), key)
-					removeKeyRecursive(v.(map[string]interface{}), key)
-				}
-
-				if !compareJSONFields(v, cassette[i]) {
-					return false
-				}
-			}
+		// compare list of maps[string]interface{} without order and without ignored keys
+		matched := 0
 
-			return true
-		}
-
-		for k := range requestMap {
-			if _, ok := cassetteMap[k]; !ok {
-				return false
-			}
+		reqVisited := make([]bool, len(request))
+		casVisited := make([]bool, len(cassette))
 
-			if !compareJSONFields(requestMap[k], cassetteMap[k]) {
-				return false
-			}
-		}
-
-		return true
-	default:
-		return reflect.DeepEqual(request, cassette)
-	}
-}
-
-// normalizeMaps normalize 2 lists of simple maps
-// from [{ "name": "foo", "value": "bar" }, { "name": "baz", "value": "qux" }] to { "foo": "bar", "baz": "qux" }
-// returns KeyIndex and ValueIndex errors if the supported key or value are not found
-func normalizeMaps(request, cassette []interface{}) (requestMap, cassetteMap map[string]interface{}, err error) {
-	requestMap = make(map[string]interface{})
-	cassetteMap = make(map[string]interface{})
-
-	for _, v := range request {
-		rmap, ok := v.(map[string]interface{})
-		if !ok {
-			return nil, nil, ErrNotComparable
-		}
-
-		var keyIndex, key string
-		for _, key = range supportedMapKeys {
-			if keyIndex, ok = rmap[key].(string); ok {
-				break
+		for i := range request {
+			if reqVisited[i] {
+				continue
 			}
-		}
 
-		if !ok {
-			return nil, nil, fmt.Errorf("%w: %s", ErrKeyIndex, key)
-		}
-
-		var value interface{}
-
-		var valueKey string
-		for _, valueKey = range supportedMapValues {
-			if value, ok = rmap[valueKey]; ok {
-				break
+			// cleanup ignored keys
+			for _, key := range BodyMatcherIgnore {
+				removeKeyRecursive(request[i].(map[string]interface{}), key)
 			}
-		}
-
-		if !ok {
-			return nil, nil, fmt.Errorf("%w: %s", ErrValueIndex, valueKey)
-		}
-
-		requestMap[keyIndex] = value
-	}
 
-	for _, v := range cassette {
-		cmap, ok := v.(map[string]interface{})
-		if !ok {
-			return nil, nil, ErrNotComparable
-		}
-
-		var keyIndex, key string
-		for _, key = range supportedMapKeys {
-			if keyIndex, ok = cmap[key].(string); ok {
-				break
-			}
-		}
+			for j := range cassette {
+				if casVisited[j] {
+					continue
+				}
 
-		if !ok {
-			return nil, nil, fmt.Errorf("%w: %s", ErrKeyIndex, key)
-		}
+				// cleanup ignored keys
+				for _, key := range BodyMatcherIgnore {
+					removeKeyRecursive(cassette[j].(map[string]interface{}), key)
+				}
 
-		var value interface{}
+				if compareJSONFields(request[i], cassette[j]) {
+					matched++
+					reqVisited[i] = true
+					casVisited[j] = true
 
-		var valueKey string
-		for _, valueKey = range supportedMapValues {
-			if value, ok = cmap[valueKey]; ok {
-				break
+					break
+				}
 			}
 		}
 
-		if !ok {
-			return nil, nil, fmt.Errorf("%w: %s", ErrValueIndex, valueKey)
-		}
-
-		cassetteMap[keyIndex] = value
+		return matched == len(request)
+	default:
+		return reflect.DeepEqual(request, cassette)
 	}
-
-	return requestMap, cassetteMap, nil
 }

internal/acctest/vcr.go

@@ -50,6 +50,17 @@ var BodyMatcherIgnore = []string{
 	"mnq_nats_subject",
 }
 
+// removeKeyRecursive removes a key from a map and all its nested maps
+func removeKeyRecursive(m map[string]interface{}, key string) {
+	delete(m, key)
+
+	for _, v := range m {
+		if v, ok := v.(map[string]interface{}); ok {
+			removeKeyRecursive(v, key)
+		}
+	}
+}
+
 // getTestFilePath returns a valid filename path based on the go test name and suffix. (Take care of non fs friendly char)
 func getTestFilePath(t *testing.T, pkgFolder string, suffix string) string {
 	t.Helper()
@@ -132,8 +143,7 @@ func cassetteBodyMatcher(request *http.Request, cassette cassette.Request) bool
 		// actualRequest contains JSON but cassette may not contain JSON, this doesn't match in this case
 		return false
 	}
-
-	// Remove keys that should be ignored during comparison
+	// remove keys that should be ignored during comparison
 	for _, key := range BodyMatcherIgnore {
 		removeKeyRecursive(requestJSON, key)
 		removeKeyRecursive(cassetteJSON, key)
@@ -142,16 +152,6 @@ func cassetteBodyMatcher(request *http.Request, cassette cassette.Request) bool
 	return compareJSONBodies(requestJSON, cassetteJSON)
 }
 
-func removeKeyRecursive(m map[string]interface{}, key string) {
-	delete(m, key)
-
-	for _, v := range m {
-		if v, ok := v.(map[string]interface{}); ok {
-			removeKeyRecursive(v, key)
-		}
-	}
-}
-
 // CassetteMatcher is a custom matcher that check equivalence of a played request against a recorded one
 // It compares method, path and query but will remove unwanted values from query
 func CassetteMatcher(request *http.Request, cassette cassette.Request) bool {