feat: support matching on arrays nested in the body

If there is an array nested within a JSON body on the pact, the interaction was previously skipped. Now it can be matched on, allowing for functionality such as waiting for N interactions to work with these requests.

Author: joshkeegan-form3

internal/app/pactproxy/constraint.go

@@ -1,9 +1,12 @@
 package pactproxy
 
 import (
+	"fmt"
 	"strings"
 )
 
+const fmtLen = "_length_"
+
 type interactionConstraint struct {
 	Interaction string        `json:"interaction"`
 	Path        string        `json:"path"`
@@ -15,3 +18,34 @@ type interactionConstraint struct {
 func (i interactionConstraint) Key() string {
 	return strings.Join([]string{i.Interaction, i.Path}, "_")
 }
+
+func (i interactionConstraint) Check(expectedValues []interface{}, actualValue interface{}) error {
+	if i.Format == fmtLen {
+		if len(expectedValues) != 1 {
+			return fmt.Errorf(
+				"expected single positive integer value for path %q length constraint, but there are %v expected values",
+				i.Path, len(expectedValues))
+		}
+		expected, ok := expectedValues[0].(int)
+		if !ok || expected < 0 {
+			return fmt.Errorf("expected value for %q length constraint must be a positive integer", i.Path)
+		}
+
+		actualSlice, ok := actualValue.([]interface{})
+		if !ok {
+			return fmt.Errorf("value at path %q must be an array due to length constraint", i.Path)
+		}
+		if expected != len(actualSlice) {
+			return fmt.Errorf("value of length %v at path %q does not match length constraint %v",
+				expected, i.Path, len(actualSlice))
+		}
+		return nil
+	}
+
+	expected := fmt.Sprintf(i.Format, expectedValues...)
+	actual := fmt.Sprintf("%v", actualValue)
+	if expected != actual {
+		return fmt.Errorf("value %q at path %q does not match constraint %q", actual, i.Path, expected)
+	}
+	return nil
+}

internal/app/pactproxy/interaction.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"mime"
-	"reflect"
 	"regexp"
 	"strings"
 	"sync"
@@ -202,6 +201,8 @@ func getPathRegex(matchingRules map[string]interface{}) (string, error) {
 	return regexString, nil
 }
 
+// Gets the pact JSON file style matching rules from the "matchingRules" property of the request.
+// Note that Pact DSL style matching rules within the body are identified later when adding JSON constraints.
 func getMatchingRules(request map[string]interface{}) map[string]interface{} {
 	rules, hasRules := request["matchingRules"]
 	if !hasRules {
@@ -272,22 +273,40 @@ func parseMediaType(request map[string]interface{}) (string, error) {
 // have a corresponding matching rule
 func (i *Interaction) addJSONConstraintsFromPact(path string, matchingRules map[string]bool, values map[string]interface{}) {
 	for k, v := range values {
-		switch val := v.(type) {
-		case map[string]interface{}:
-			if _, exists := val["json_class"]; exists {
-				continue
-			}
-			i.addJSONConstraintsFromPact(path+"."+k, matchingRules, val)
-		default:
-			p := path + "." + k
-			if _, hasRule := matchingRules[p]; !hasRule {
-				i.AddConstraint(interactionConstraint{
-					Path:   p,
-					Format: "%v",
-					Values: []interface{}{val},
-				})
-			}
+		i.addJSONConstraintsFromPactAny(path+"."+k, matchingRules, v)
+	}
+}
+
+func (i *Interaction) addJSONConstraintsFromPactAny(path string, matchingRules map[string]bool, value interface{}) {
+	if _, hasRule := matchingRules[path]; hasRule {
+		return
+	}
+
+	switch val := value.(type) {
+	case map[string]interface{}:
+		// json_class is used to test for a Pact DSL-style matching rule within the body. The matchingRules passed
+		// to this method will not include these.
+		if _, exists := val["json_class"]; exists {
+			return
+		}
+		i.addJSONConstraintsFromPact(path, matchingRules, val)
+	case []interface{}:
+		// Create constraints for each element in the array. This allows matching rules to override them.
+		for j := range val {
+			i.addJSONConstraintsFromPactAny(fmt.Sprintf("%v[%v]", path, j), matchingRules, val[j])
 		}
+		// Length constraint so that requests with additional elements at the end of the array will not match
+		i.AddConstraint(interactionConstraint{
+			Path:   path,
+			Format: fmtLen,
+			Values: []interface{}{len(val)},
+		})
+	default:
+		i.AddConstraint(interactionConstraint{
+			Path:   path,
+			Format: "%v",
+			Values: []interface{}{val},
+		})
 	}
 }
 
@@ -352,22 +371,16 @@ func (i *Interaction) EvaluateConstraints(request requestDocument, interactions
 			}
 		}
 
-		actual := ""
 		val, err := jsonpath.Get(request.encodeValues(constraint.Path), map[string]interface{}(request))
 		if err != nil {
-			log.Warn(err)
-		}
-		if reflect.TypeOf(val) == reflect.TypeOf([]interface{}{}) {
-			log.Infof("skipping matching on []interface{} type for path '%s'", constraint.Path)
+			violations = append(violations,
+				fmt.Sprintf("constraint path %q cannot be resolved within request: %q", constraint.Path, err))
+			result = false
 			continue
 		}
-		if err == nil {
-			actual = fmt.Sprintf("%v", val)
-		}
 
-		expected := fmt.Sprintf(constraint.Format, values...)
-		if actual != expected {
-			violations = append(violations, fmt.Sprintf("value '%s' at path '%s' does not match constraint '%s'", actual, constraint.Path, expected))
+		if err := constraint.Check(values, val); err != nil {
+			violations = append(violations, err.Error())
 			result = false
 		}
 	}

internal/app/pactproxy/interaction_test.go

@@ -120,6 +120,114 @@ func TestLoadInteractionPlainTextConstraints(t *testing.T) {
 	}
 }
 
+func TestLoadInteractionJSONConstraints(t *testing.T) {
+	arrMatchersNotPresent := `{
+		"description": "A request to create an address",
+		"request": {
+		  "method": "POST",
+		  "path": "/addresses",
+		  "headers": {
+			"Content-Type": "application/json"
+		  },
+		  "body": {
+			"addressLines": ["line 1", "line 2"]
+		  }
+		},
+		"response": {
+		  "status": 200,
+		  "headers": {
+			"Content-Type": "application/json"
+		  },
+		  "body": {
+			"addressLines": ["line 1", "line 2"]
+		  }
+		}
+	  }`
+	arrMatcherPresent :=
+		`{
+		"description": "A request to create an address",
+		"request": {
+		  "method": "POST",
+		  "path": "/addresses",
+		  "headers": {
+			"Content-Type": "application/json"
+		  },
+		  "body": {
+			"addressLines": ["line 1", "line 2"]
+		  },
+		  "matchingRules": {
+			"$.body.addressLines[0]": {
+			  "regex": ".*"
+			}
+		  }
+		},
+		"response": {
+		  "status": 200,
+		  "headers": {
+			"Content-Type": "application/json"
+		  },
+		  "body": {
+			"addressLines": ["line 1", "line 2"]
+		  }
+		}
+	  }`
+	tests := []struct {
+		name            string
+		interaction     []byte
+		wantConstraints []interactionConstraint
+	}{
+		{
+			name:        "array and matcher not present - interactions are created per element",
+			interaction: []byte(arrMatchersNotPresent),
+			wantConstraints: []interactionConstraint{
+				{
+					Path:   "$.body.addressLines[0]",
+					Format: "%v",
+					Values: []interface{}{"line 1"},
+				},
+				{
+					Path:   "$.body.addressLines[1]",
+					Format: "%v",
+					Values: []interface{}{"line 2"},
+				},
+				{
+					Path:   "$.body.addressLines",
+					Format: fmtLen,
+					Values: []interface{}{2},
+				},
+			},
+		},
+		{
+			name:        "array and matcher present - interaction is not created for matched element",
+			interaction: []byte(arrMatcherPresent),
+			wantConstraints: []interactionConstraint{
+				{
+					Path:   "$.body.addressLines[1]",
+					Format: "%v",
+					Values: []interface{}{"line 2"},
+				},
+				{
+					Path:   "$.body.addressLines",
+					Format: fmtLen,
+					Values: []interface{}{2},
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			interaction, err := LoadInteraction(tt.interaction, "alias")
+			require.NoError(t, err)
+
+			actual := make([]interactionConstraint, 0, len(interaction.constraints))
+			for _, constraint := range interaction.constraints {
+				actual = append(actual, constraint)
+			}
+			assert.ElementsMatch(t, tt.wantConstraints, actual)
+		})
+	}
+}
+
 // This test asserts that given a pact v3-style nested matching rule, a constraint
 // is not created for the corresponding property
 func TestV3MatchingRulesLeadToCorrectConstraints(t *testing.T) {

internal/app/proxy_stage_test.go

@@ -451,8 +451,7 @@ func (s *ProxyStage) the_nth_response_body_is(n int, data []byte) *ProxyStage {
 	s.assert.GreaterOrEqual(len(s.responseBodies), n, "number of request bodies is les than expected")
 
 	body := s.responseBodies[n-1]
-	c := bytes.Compare(body, data)
-	s.assert.Equal(0, c, "Expected body did not match")
+	s.assert.Equal(data, body, "Expected body did not match")
 	return s
 }