feat(acctest): compare slice of map[string]interface{}

Author: Gnoale

internal/acctest/acctest_test.go

@@ -173,6 +173,7 @@ var simpleSliceOfStringsRequest = `{
   ]
 }
 `
+
 var simpleSliceOfStringsCassette = `{
   "strings": [
     "3",
@@ -182,6 +183,162 @@ var simpleSliceOfStringsCassette = `{
 }
 `
 
+var ludacrisBodyRequest = `{
+  "payload": {
+    "artists": [
+		{
+			"name": "Ludacris",
+			"age": 45,
+			"songs": ["Ludacris", "Ludacris", "Ludacris"]
+		}
+	}
+  }
+}
+`
+
+var jdillaBodyCassette = `{
+  "payload": {
+    "artists": [
+		{
+			"name": "Jdilla",
+			"age": 54,
+			"songs": ["this", "is", "jdilla"]
+		}
+	]
+  }
+}
+`
+
+var requestInstanceSettings = `{
+  "settings": [
+    {
+      "name": "max_connections",
+      "value": "200"
+    },
+    {
+      "name": "max_parallel_workers",
+      "value": "2"
+    },
+    {
+      "name": "effective_cache_size",
+      "value": "1300"
+    },
+    {
+      "name": "maintenance_work_mem",
+      "value": "150"
+    },
+    {
+      "name": "max_parallel_workers_per_gather",
+      "value": "2"
+    },
+    {
+      "name": "work_mem",
+      "value": "4"
+    }
+  ]
+}
+`
+
+var cassetteInstanceSettings = `{
+  "settings": [
+    {
+      "name": "maintenance_work_mem",
+      "value": "150"
+    },
+    {
+      "name": "effective_cache_size",
+      "value": "1300"
+    },
+    {
+      "name": "work_mem",
+      "value": "4"
+    },
+    {
+      "name": "max_parallel_workers",
+      "value": "2"
+    },
+    {
+      "name": "max_parallel_workers_per_gather",
+      "value": "2"
+    },
+    {
+      "name": "max_connections",
+      "value": "200"
+    }
+  ]
+}
+`
+
+var objectBodyRequest = `{
+  "Id": "MyPolicy",
+  "Statement": [
+    {
+      "Action": [
+        "s3:ListBucket",
+        "s3:GetObject"
+      ],
+      "Effect": "Allow",
+      "Principal": {
+        "SCW": "*"
+      },
+      "Resource": [
+        "tf-tests-scw-obp-basic-4713290580220176511",
+        "tf-tests-scw-obp-basic-4713290580220176511/*"
+      ],
+      "Sid": "GrantToEveryone"
+    },
+    {
+      "Action": [
+        "s3:ListBucket",
+        "s3:GetObject"
+      ],
+      "Effect": "Allow",
+      "Principal": {
+        "SCW": "*"
+      },
+      "Sid": "GrantToEveryone",
+	  "project_id": "1234567890"
+    }
+  ],
+  "Version": "2012-10-17"
+}
+`
+
+var objectBodyCassette = `{
+  "Id": "MyPolicy",
+  "Statement": [
+    {
+      "Action": [
+        "s3:ListBucket",
+        "s3:GetObject"
+      ],
+      "Effect": "Allow",
+      "Principal": {
+        "SCW": "*"
+      },
+      "Sid": "GrantToEveryone",
+      "project_id": "9876543210"
+    },
+    {
+      "Action": [
+        "s3:ListBucket",
+        "s3:GetObject"
+      ],
+      "Effect": "Allow",
+      "Principal": {
+        "SCW": "*"
+      },
+      "Sid": "GrantToEveryone",
+      "Resource": [
+        "tf-tests-scw-obp-basic-1234567890",
+        "tf-tests-scw-obp-basic-1234567890/*"
+      ]
+    }
+  ],
+  "Version": "2012-10-17"
+}
+`
+
 // 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)
@@ -197,7 +354,7 @@ var testBodyMatcherCases = []struct {
 	cassetteBody *cassette.Request
 	shouldMatch  bool
 }{
-	// create bar compare with foo
+	// bar does not match foo
 	{
 		requestBody: newRequest(http.MethodPost, "https://api.scaleway.com/iam/v1alpha1/users", strings.NewReader(barMemberCreationBody)),
 		cassetteBody: &cassette.Request{
@@ -208,7 +365,7 @@ var testBodyMatcherCases = []struct {
 		},
 		shouldMatch: false,
 	},
-	// create bar compare with bar
+	// bar matches bar
 	{
 		requestBody: newRequest(http.MethodPost, "https://api.scaleway.com/iam/v1alpha1/users", strings.NewReader(barMemberCreationBody)),
 		cassetteBody: &cassette.Request{
@@ -231,8 +388,6 @@ var testBodyMatcherCases = []struct {
 		shouldMatch: true,
 	},
 	// patch secret with nested slices of map[string]interface{} in different order
-	// we cannot user deep equal because the order of the slices is different although the values are the same
-	// it is not possible to sort them because they are not comparable (map[string]interface{})
 	{
 		requestBody: newRequest(http.MethodPatch, "https://api.scaleway.com/secrets/v1/secrets/123", strings.NewReader(secretPatchBodyRequest)),
 		cassetteBody: &cassette.Request{
@@ -243,7 +398,28 @@ var testBodyMatcherCases = []struct {
 		},
 		shouldMatch: true,
 	},
-	// compare nested slices of different integers
+	{
+		requestBody: newRequest(http.MethodPost, "https://api.scaleway.com/iam/v1alpha1/users", strings.NewReader(requestInstanceSettings)),
+		cassetteBody: &cassette.Request{
+			URL:           "https://api.scaleway.com/iam/v1alpha1/users",
+			Method:        http.MethodPost,
+			Body:          cassetteInstanceSettings,
+			ContentLength: int64(len(cassetteInstanceSettings)),
+		},
+		shouldMatch: true,
+	},
+	// complex slice of maps case
+	{
+		requestBody: newRequest(http.MethodPost, "https://api.scaleway.com/iam/v1alpha1/policies", strings.NewReader(objectBodyRequest)),
+		cassetteBody: &cassette.Request{
+			URL:           "https://api.scaleway.com/iam/v1alpha1/policies",
+			Method:        http.MethodPost,
+			Body:          objectBodyCassette,
+			ContentLength: int64(len(objectBodyCassette)),
+		},
+		shouldMatch: true,
+	},
+	// compare slices of different integers
 	{
 		requestBody: newRequest(http.MethodPost, "https://api.scaleway.com/iam/v1alpha1/users", strings.NewReader(integertestBodyRequest)),
 		cassetteBody: &cassette.Request{
@@ -254,7 +430,7 @@ var testBodyMatcherCases = []struct {
 		},
 		shouldMatch: false,
 	},
-	// compare nested slices of same integers in different order
+	// compare slices of same integers in different order
 	{
 		requestBody: newRequest(http.MethodPost, "https://api.scaleway.com/iam/v1alpha1/users", strings.NewReader(integerBodyRequestOutOfOrder)),
 		cassetteBody: &cassette.Request{
@@ -265,7 +441,7 @@ var testBodyMatcherCases = []struct {
 		},
 		shouldMatch: true,
 	},
-	// compare nested slices of slices of strings
+	// compare slices of slices of strings in different order
 	{
 		requestBody: newRequest(http.MethodPost, "https://api.scaleway.com/iam/v1alpha1/users", strings.NewReader(nestedSliceOfSlicesRequest)),
 		cassetteBody: &cassette.Request{
@@ -286,7 +462,7 @@ var testBodyMatcherCases = []struct {
 		},
 		shouldMatch: true,
 	},
-	// compare simple slice of strings
+	// compare slices of strings in different order
 	{
 		requestBody: newRequest(http.MethodPost, "https://api.scaleway.com/iam/v1alpha1/users", strings.NewReader(simpleSliceOfStringsRequest)),
 		cassetteBody: &cassette.Request{
@@ -297,13 +473,26 @@ var testBodyMatcherCases = []struct {
 		},
 		shouldMatch: true,
 	},
+	// ludacris does not match jdilla
+	{
+		requestBody: newRequest(http.MethodPost, "https://api.scaleway.com/iam/v1alpha1/users", strings.NewReader(ludacrisBodyRequest)),
+		cassetteBody: &cassette.Request{
+			URL:           "https://api.scaleway.com/iam/v1alpha1/users",
+			Method:        http.MethodPost,
+			Body:          jdillaBodyCassette,
+			ContentLength: int64(len(jdillaBodyCassette)),
+		},
+		shouldMatch: false,
+	},
 }
 
 func TestCassetteMatcher(t *testing.T) {
 	for i, test := range testBodyMatcherCases {
 		shouldMatch := acctest.CassetteMatcher(test.requestBody, *test.cassetteBody)
 		if shouldMatch != test.shouldMatch {
 			t.Errorf("test %d: expected %v, got %v", i, test.shouldMatch, shouldMatch)
+			t.Errorf("requestBody: %s", test.requestBody.Body)
+			t.Errorf("cassetteBody: %s", test.cassetteBody.Body)
 		}
 	}
 }

internal/acctest/compare.go

@@ -7,8 +7,8 @@ import (
 	"strings"
 )
 
-// compareJSONFields compare two given json fields
-// it will recurse on map[string]interface{} and []interface{}
+// 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 {
 	switch requestValue := requestValue.(type) {
 	case string:
@@ -43,17 +43,6 @@ func compareJSONBodies(request, cassette map[string]interface{}) bool {
 		}
 	}
 
-	// TODO: record back ipam/TestAccIPAMIPReverseDNS_Basic
-
-	//	for key, cassetteValue := range cassette {
-	//		if _, ok := request[key]; !ok && cassetteValue != nil {
-	//			// Fails match if cassettes contains a field not in actual requests
-	//			// Fields should not disappear from requests unless a sdk breaking change
-	//			// We ignore if field is nil in cassette as it could be an old deprecated and unused field
-	//			return false
-	//		}
-	//	}
-
 	return true
 }
 
@@ -150,9 +139,8 @@ func compareStringSlices(request, cassette []string) bool {
 	return true
 }
 
-// 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 impossible to sort
+// compareSlices compares two slices of interface{}
+// in case of slice of map[string]interface{}, it will attempt to find a match in the other slice without taking into account the order
 func compareSlices(request, cassette []interface{}) bool {
 	if len(request) != len(cassette) {
 		return false
@@ -168,6 +156,7 @@ func compareSlices(request, cassette []interface{}) bool {
 		for i, v := range request {
 			requestStrings[i] = v.(string)
 		}
+
 		cassetteStrings := make([]string, len(cassette))
 		for i, v := range cassette {
 			cassetteStrings[i] = v.(string)
@@ -190,7 +179,43 @@ func compareSlices(request, cassette []interface{}) bool {
 
 		return true
 	case map[string]interface{}:
-		return true
+		// compare list of maps[string]interface{} without order and without ignored keys
+		matched := 0
+
+		reqVisited := make([]bool, len(request))
+		casVisited := make([]bool, len(cassette))
+
+		for i := range request {
+			if reqVisited[i] {
+				continue
+			}
+
+			// cleanup ignored keys
+			for _, key := range BodyMatcherIgnore {
+				removeKeyRecursive(request[i].(map[string]interface{}), key)
+			}
+
+			for j := range cassette {
+				if casVisited[j] {
+					continue
+				}
+
+				// cleanup ignored keys
+				for _, key := range BodyMatcherIgnore {
+					removeKeyRecursive(cassette[j].(map[string]interface{}), key)
+				}
+
+				if compareJSONFields(request[i], cassette[j]) {
+					matched++
+					reqVisited[i] = true
+					casVisited[j] = true
+
+					break
+				}
+			}
+		}
+
+		return matched == len(request)
 	default:
 		return reflect.DeepEqual(request, cassette)
 	}