wip

Author: Gnoale

internal/acctest/acctest_test.go

@@ -101,37 +101,31 @@ var secretPatchBodyRequest = `{
 
 var integertestBodyRequest = `{
   "akey": "avalue",
-  "nested_integer": {
-    "integers": [
-      1,
-      2,
-      3
-    ]
-  }
+   "integers": [
+     1,
+     2,
+     3
+   ]
 }
 `
 
 var integertestBodyCassette = `{
   "akey": "avalue",
-  "nested_integer": {
-    "integers": [
-      4,
-      5,
-      6
-    ]
-  }
+   "integers": [
+     4,
+     5,
+     6
+   ]
 }
 `
 
 var integerBodyRequestOutOfOrder = `{
   "akey": "avalue",
-  "nested_integer": {
-    "integers": [
-      2,
-      1,
-      3
-    ]
-  }
+   "integers": [
+     2,
+     1,
+     3
+   ]
 }
 `
 
@@ -171,6 +165,23 @@ var nestedSliceOfSlicesCassette = `{
 }
 `
 
+var simpleSliceOfStringsRequest = `{
+  "strings": [
+    "1",
+    "2",
+    "3"
+  ]
+}
+`
+var simpleSliceOfStringsCassette = `{
+  "strings": [
+    "3",
+    "2",
+    "1"
+  ]
+}
+`
+
 // we don't use httptest.NewRequest because it does not set the GetBody func
 func newRequest(method, url string, body io.Reader) *http.Request {
 	req, err := http.NewRequestWithContext(context.Background(), method, url, body)
@@ -275,6 +286,17 @@ var testBodyMatcherCases = []struct {
 		},
 		shouldMatch: true,
 	},
+	// compare simple slice of strings
+	{
+		requestBody: newRequest(http.MethodPost, "https://api.scaleway.com/iam/v1alpha1/users", strings.NewReader(simpleSliceOfStringsRequest)),
+		cassetteBody: &cassette.Request{
+			URL:           "https://api.scaleway.com/iam/v1alpha1/users",
+			Method:        http.MethodPost,
+			Body:          simpleSliceOfStringsCassette,
+			ContentLength: int64(len(simpleSliceOfStringsCassette)),
+		},
+		shouldMatch: true,
+	},
 }
 
 func TestCassetteMatcher(t *testing.T) {

internal/acctest/compare.go

@@ -9,17 +9,14 @@ import (
 
 // compareJSONFields compare two given json fields
 // it will recurse on map[string]interface{} and []interface{}
-// and compare string fields with compareJSONFieldsStrings
 func compareJSONFields(requestValue, cassetteValue interface{}) bool {
 	switch requestValue := requestValue.(type) {
 	case string:
-		return compareJSONFieldsStrings(requestValue, cassetteValue.(string))
+		return compareFieldsStrings(requestValue, cassetteValue.(string))
 	case map[string]interface{}:
 		return compareJSONBodies(requestValue, cassetteValue.(map[string]interface{}))
 	case []interface{}:
-		return compareJSONSlices(requestValue, cassetteValue.([]interface{}))
-	case []string:
-		return compareStringSlices(requestValue, cassetteValue.([]string))
+		return compareSlices(requestValue, cassetteValue.([]interface{}))
 	default:
 		return reflect.DeepEqual(requestValue, cassetteValue)
 	}
@@ -74,7 +71,7 @@ func compareFormBodies(request, cassette url.Values) bool {
 			continue
 		}
 
-		if !compareJSONFields(requestValue, cassette[key]) {
+		if !compareStringSlices(requestValue, cassette[key]) {
 			return false
 		}
 	}
@@ -91,9 +88,9 @@ func compareFormBodies(request, cassette url.Values) bool {
 	return true
 }
 
-// compareJSONFieldsStrings compare two strings from request JSON bodies
+// compareFieldsStrings compare two strings from request JSON bodies
 // has special case when string are terraform generated names
-func compareJSONFieldsStrings(expected, actual string) bool {
+func compareFieldsStrings(expected, actual string) bool {
 	if expected == actual {
 		return true
 	}
@@ -145,7 +142,7 @@ func compareStringSlices(request, cassette []string) bool {
 	})
 
 	for i, v := range request {
-		if !compareJSONFieldsStrings(v, cassette[i]) {
+		if !compareFieldsStrings(v, cassette[i]) {
 			return false
 		}
 	}
@@ -155,8 +152,8 @@ func compareStringSlices(request, cassette []string) bool {
 
 // compareJSONSlices compares two slices of interface{}
 // if the slices are comparable (string or float64), it will sort them and compare them
-// it returns true in case of slice of map[string]interface{} because it is not possible to sort them
-func compareJSONSlices(request, cassette []interface{}) bool {
+// it returns true in case of slice of map[string]interface{} because it is impossible to sort
+func compareSlices(request, cassette []interface{}) bool {
 	if len(request) != len(cassette) {
 		return false
 	}
@@ -165,23 +162,18 @@ func compareJSONSlices(request, cassette []interface{}) bool {
 		return true
 	}
 
-	// try to infer the type of the slice, sort it and compare all elements
 	switch request[0].(type) {
 	case string:
-		sort.Slice(request, func(i, j int) bool {
-			return request[i].(string) < request[j].(string)
-		})
-		sort.Slice(cassette, func(i, j int) bool {
-			return cassette[i].(string) < cassette[j].(string)
-		})
-
-		for i := range request {
-			if !compareJSONFieldsStrings(request[i].(string), cassette[i].(string)) {
-				return false
-			}
+		requestStrings := make([]string, len(request))
+		for i, v := range request {
+			requestStrings[i] = v.(string)
+		}
+		cassetteStrings := make([]string, len(cassette))
+		for i, v := range cassette {
+			cassetteStrings[i] = v.(string)
 		}
 
-		return true
+		return compareStringSlices(requestStrings, cassetteStrings)
 	case float64:
 		sort.Slice(request, func(i, j int) bool {
 			return request[i].(float64) < request[j].(float64)

internal/acctest/vcr.go

@@ -119,7 +119,6 @@ func cassetteBodyMatcher(request *http.Request, cassette cassette.Request) bool
 			requestValues.Del(key)
 		}
 
-		// Compare url values
 		return compareFormBodies(requestValues, cassette.Form)
 	}