Unable to match mock when body is raw array

This is caused by 2 issues:
1. The JSON compare method uses a map[string]interface{}, but it really
   should use interface{} to support arrays
2. The brackets '[]' in the spec trigger the regexp matcher, so it never
   works. The solution is to remove support for regexp on body matching
(it's undocumented) and provided a separate `BodyRegexp` method if
users want to match using regexp. This could potentially break some
existing tests, but the inclusion of this new method should ease the
migration, and I think not supporting matching arrays is a bigger issue
that can't be worked around.

Author: Stein Fletcher

mocks.go

@@ -269,6 +269,7 @@ type MockRequest struct {
 	cookiePresent      []string
 	cookieNotPresent   []string
 	body               string
+	bodyRegexp         string
 	matchers           []Matcher
 }
 
@@ -472,6 +473,12 @@ func (r *MockRequest) Body(b string) *MockRequest {
 	return r
 }
 
+// BodyRegexp configures the mock request to match the given body using the regexp matcher
+func (r *MockRequest) BodyRegexp(b string) *MockRequest {
+	r.body = b
+	return r
+}
+
 // Bodyf configures the mock request to match the given body. Supports formatting the body
 func (r *MockRequest) Bodyf(format string, args ...interface{}) *MockRequest {
 	return r.Body(fmt.Sprintf(format, args...))
@@ -1039,17 +1046,11 @@ var bodyMatcher = func(req *http.Request, spec *MockRequest) error {
 		return nil
 	}
 
-	// Perform regexp match
-	match, _ := regexp.MatchString(mockBody, bodyStr)
-	if match {
-		return nil
-	}
-
 	// Perform JSON match
-	var reqJSON map[string]interface{}
+	var reqJSON interface{}
 	reqJSONErr := json.Unmarshal(body, &reqJSON)
 
-	var matchJSON map[string]interface{}
+	var matchJSON interface{}
 	specJSONErr := json.Unmarshal([]byte(mockBody), &matchJSON)
 
 	isJSON := reqJSONErr == nil && specJSONErr == nil
@@ -1064,6 +1065,38 @@ var bodyMatcher = func(req *http.Request, spec *MockRequest) error {
 	return fmt.Errorf("received body did not match expected mock body\n%s", diff(mockBody, bodyStr))
 }
 
+var bodyRegexpMatcher = func(req *http.Request, spec *MockRequest) error {
+	expression := spec.bodyRegexp
+
+	if len(expression) == 0 {
+		return nil
+	}
+
+	if req.Body == nil {
+		return errors.New("expected a body but received none")
+	}
+
+	body, err := ioutil.ReadAll(req.Body)
+	if err != nil {
+		return err
+	}
+	if len(body) == 0 {
+		return errors.New("expected a body but received none")
+	}
+
+	// replace body so it can be read again
+	req.Body = ioutil.NopCloser(bytes.NewReader(body))
+
+	// Perform regexp match
+	bodyStr := string(body)
+	match, _ := regexp.MatchString(expression, bodyStr)
+	if match {
+		return nil
+	}
+
+	return fmt.Errorf("received body did not match expected mock body\n%s", diff(expression, bodyStr))
+}
+
 func errorOrNil(statement bool, errorMessage func() string) error {
 	if statement {
 		return nil
@@ -1087,6 +1120,7 @@ var defaultMatchers = []Matcher{
 	formDataPresentMatcher,
 	formDataNotPresentMatcher,
 	bodyMatcher,
+	bodyRegexpMatcher,
 	cookieMatcher,
 	cookiePresentMatcher,
 	cookieNotPresentMatcher,

mocks_test.go

@@ -617,10 +617,6 @@ func TestMocks_BodyMatcher(t *testing.T) {
 	}{
 		{`{"a": 1}`, "", nil},
 		{``, `{"a":1}`, errors.New("expected a body but received none")},
-		{"golang\n", "go[lang]?", nil},
-		{"golang\n", "go[lang]?", nil},
-		{"go\n", "go[lang]?", nil},
-		{`{"a":"12345"}\n`, `{"a":"12345"}`, nil},
 		{`{"x":"12345"}`, `{"x":"12345"}`, nil},
 		{`{"a": 12345, "b": [{"key": "c", "value": "result"}]}`,
 			`{"b":[{"key":"c","value":"result"}],"a":12345}`, nil},
@@ -635,6 +631,33 @@ func TestMocks_BodyMatcher(t *testing.T) {
 	}
 }
 
+func TestMocks_BodyMatcher_Regexp(t *testing.T) {
+	tests := []struct {
+		requestBody   string
+		matchBody     string
+		expectedError error
+	}{
+		{"golang\n", "go[lang]?", nil},
+		{"golang\n", "go[lang]?", nil},
+		{"go\n", "go[lang]?", nil},
+		{`{"a":"12345"}\n`, `{"a":"12345"}`, nil},
+	}
+
+	for _, test := range tests {
+		t.Run(fmt.Sprintf("body=%v", test.matchBody), func(t *testing.T) {
+			req := httptest.NewRequest(http.MethodGet, "/path", strings.NewReader(test.requestBody))
+			matchError := bodyRegexpMatcher(req, NewMock().Get("/path").Body(test.matchBody))
+			assert.Equal(t, test.expectedError, matchError)
+		})
+	}
+}
+
+func TestMocks_BodyMatcher_SupportsRawArrays(t *testing.T) {
+	req := httptest.NewRequest(http.MethodGet, "/path", strings.NewReader(`[{"a":1, "b": 2, "c": "something"}]`))
+	matchError := bodyMatcher(req, NewMock().Get("/path").JSON(`[{"b": 2, "c": "something", "a": 1}]`))
+	assert.NoError(t, matchError)
+}
+
 func TestMocks_RequestBody(t *testing.T) {
 	tests := map[string]struct {
 		requestBody interface{}