fix(acctest): perform deepequality on nested request body

Author: Gnoale

internal/acctest/acctest_test.go

@@ -0,0 +1,106 @@
+package acctest_test
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/acctest"
+	"gopkg.in/dnaeon/go-vcr.v3/cassette"
+)
+
+var barMemberCreationBody = `{
+  "organization_id": "6867048b-fe12-4e96-835e-41c79a39604b",
+  "tags": [
+    "bar"
+  ],
+  "member": {
+    "email": "[email protected]",
+    "send_password_email": false,
+    "send_welcome_email": false,
+    "username": "bar",
+    "password": "",
+    "first_name": "",
+    "last_name": "",
+    "phone_number": "",
+    "locale": ""
+  }
+}
+`
+
+var fooMemberCreationBody = `{
+  "organization_id": "6867048b-fe12-4e96-835e-41c79a39604b",
+  "tags": [
+    "foo"
+  ],
+  "member": {
+    "email": "[email protected]",
+    "send_password_email": false,
+    "send_welcome_email": false,
+    "username": "foo",
+    "password": "",
+    "first_name": "",
+    "last_name": "",
+    "phone_number": "",
+    "locale": ""
+  }
+}
+`
+
+// 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)
+	if err != nil {
+		panic(err)
+	}
+
+	return req
+}
+
+var testBodyMatcherCases = []struct {
+	requestBody  *http.Request
+	cassetteBody *cassette.Request
+	shouldMatch  bool
+}{
+	{
+		requestBody: newRequest(http.MethodPost, "https://api.scaleway.com/iam/v1alpha1/users", strings.NewReader(barMemberCreationBody)),
+		cassetteBody: &cassette.Request{
+			URL:           "https://api.scaleway.com/iam/v1alpha1/users",
+			Method:        http.MethodPost,
+			Body:          fooMemberCreationBody,
+			ContentLength: int64(len(fooMemberCreationBody)),
+		},
+		shouldMatch: false,
+	},
+	{
+		requestBody: newRequest(http.MethodPost, "https://api.scaleway.com/iam/v1alpha1/users", strings.NewReader(barMemberCreationBody)),
+		cassetteBody: &cassette.Request{
+			URL:           "https://api.scaleway.com/iam/v1alpha1/users",
+			Method:        http.MethodPost,
+			Body:          barMemberCreationBody,
+			ContentLength: int64(len(barMemberCreationBody)),
+		},
+		shouldMatch: true,
+	},
+	{
+		requestBody: newRequest(http.MethodGet, "https://api.scaleway.com/iam/v1alpha1/users/6867048b-fe12-4e96-835e-41c79a39604b", nil),
+		cassetteBody: &cassette.Request{
+			URL:           "https://api.scaleway.com/iam/v1alpha1/users/6867048b-fe12-4e96-835e-41c79a39604b",
+			Method:        http.MethodGet,
+			Body:          "",
+			ContentLength: 0,
+		},
+		shouldMatch: true,
+	},
+}
+
+func TestCassetteMatcher(t *testing.T) {
+	for _, test := range testBodyMatcherCases {
+		shouldMatch := acctest.CassetteMatcher(test.requestBody, *test.cassetteBody)
+		if shouldMatch != test.shouldMatch {
+			t.Errorf("expected %v, got %v", test.shouldMatch, shouldMatch)
+		}
+	}
+}

internal/acctest/vcr.go

@@ -10,6 +10,7 @@ import (
 	"net/url"
 	"os"
 	"path/filepath"
+	"reflect"
 	"regexp"
 	"strings"
 	"testing"
@@ -74,8 +75,7 @@ func compareJSONFields(expected, actualI interface{}) bool {
 
 		return compareJSONFieldsStrings(expected.(string), actual)
 	default:
-		// Consider equality when not handled
-		return true
+		return reflect.DeepEqual(expected, actualI)
 	}
 }
 
@@ -116,39 +116,41 @@ func cassetteBodyMatcher(actualRequest *http.Request, cassetteRequest cassette.R
 	if actualRequest.Body == nil || actualRequest.ContentLength == 0 {
 		if cassetteRequest.Body == "" {
 			return true // Body match if both are empty
-		} else if _, isFile := actualRequest.Body.(*os.File); isFile {
+		}
+
+		if _, isFile := actualRequest.Body.(*os.File); isFile {
 			return true // Body match if request is sending a file, maybe do more check here
 		}
 
 		return false
 	}
 
-	actualBody, err := actualRequest.GetBody()
+	actualBodyReader, err := actualRequest.GetBody()
 	if err != nil {
 		panic(fmt.Errorf("cassette body matcher: failed to copy actualRequest body: %w", err)) // lintignore: R009
 	}
 
-	actualRawBody, err := io.ReadAll(actualBody)
+	actualBody, err := io.ReadAll(actualBodyReader)
 	if err != nil {
 		panic(fmt.Errorf("cassette body matcher: failed to read actualRequest body: %w", err)) // lintignore: R009
 	}
 
 	// Try to match raw bodies if they are not JSON (ex: cloud-init config)
-	if string(actualRawBody) == cassetteRequest.Body {
+	if string(actualBody) == cassetteRequest.Body {
 		return true
 	}
 
 	actualJSON := make(map[string]interface{})
 	cassetteJSON := make(map[string]interface{})
 
-	err = xml.Unmarshal(actualRawBody, new(interface{}))
+	// match if content is xml
+	err = xml.Unmarshal(actualBody, new(interface{}))
 	if err == nil {
-		// match if content is xml
 		return true
 	}
 
-	if !json.Valid(actualRawBody) {
-		values, err := url.ParseQuery(string(actualRawBody))
+	if !json.Valid(actualBody) {
+		values, err := url.ParseQuery(string(actualBody))
 		if err != nil {
 			panic(fmt.Errorf("cassette body matcher: failed to parse body as url values: %w", err)) // lintignore: R009
 		}
@@ -162,9 +164,9 @@ func cassetteBodyMatcher(actualRequest *http.Request, cassetteRequest cassette.R
 		return compareFormBodies(values, cassetteRequest.Form)
 	}
 
-	err = json.Unmarshal(actualRawBody, &actualJSON)
+	err = json.Unmarshal(actualBody, &actualJSON)
 	if err != nil {
-		panic(fmt.Errorf("cassette body matcher: failed to parse json body: %w", err)) // lintignore: R009
+		panic(fmt.Errorf("cassette body matcher: failed to parse request body as json: %w", err)) // lintignore: R009
 	}
 
 	err = json.Unmarshal([]byte(cassetteRequest.Body), &cassetteJSON)
@@ -182,9 +184,9 @@ func cassetteBodyMatcher(actualRequest *http.Request, cassetteRequest cassette.R
 	return compareJSONBodies(cassetteJSON, actualJSON)
 }
 
-// cassetteMatcher is a custom matcher that check equivalence of a played request against a recorded one
+// 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(actual *http.Request, expected cassette.Request) bool {
+func CassetteMatcher(actual *http.Request, expected cassette.Request) bool {
 	expectedURL, _ := url.Parse(expected.URL)
 	actualURL := actual.URL
 	actualURLValues := actualURL.Query()
@@ -297,7 +299,7 @@ func getHTTPRecoder(t *testing.T, pkgFolder string, update bool) (client *http.C
 	}(r)
 
 	// Add custom matcher for requests and cassettes
-	r.SetMatcher(cassetteMatcher)
+	r.SetMatcher(CassetteMatcher)
 
 	// Add a filter which removes Authorization headers from all requests:
 	r.AddHook(func(i *cassette.Interaction) error {