feat: add custom user package extension for MatchV2 for parsing of st…

…ructs field tags

this allows customized support for struct field parsing.

the example custom implementation could parse struct fields used to support protojson structs

examples/extensions/match_ext_test.go

@@ -0,0 +1,191 @@
+package extensions
+
+import (
+	"fmt"
+	"log"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/pact-foundation/pact-go/v2/matchers"
+	"github.com/pkg/errors"
+
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
+)
+
+var (
+	Like     = matchers.Like
+	EachLike = matchers.EachLike
+	Term     = matchers.Term
+)
+
+type (
+	StructMatcher = matchers.StructMatcher
+	Matcher       = matchers.Matcher
+)
+
+func TestMatch(t *testing.T) {
+	// mixedDTO in order to reuse protoc-gen-go where structs are compatible with protobuf and json
+	type mixedDTO struct {
+		// has tag and should be in output
+		OnlyJsonTag string `json:"onlyJsonTag"`
+		// no tag, skip
+		NoTagString string
+		// no tag, skip - this covers case of proto compatible structs that contain func fields
+		NoTagFunc           func()
+		BothUseJsonTag      int32 `protobuf:"varint,1,opt,name=both_use_json_tag,json=bothNameFromProtobufTag,proto3" json:"bothNameFromJsonTag,omitempty"`
+		ProtoWithoutJsonTag *struct {
+			OnlyJsonTag string `json:"onlyJsonTagNested"`
+			// no tag, skip
+			NoTag func()
+		} `protobuf:"bytes,7,opt,name=proto_without_json_tag,json=onlyProtobufTag,proto3,oneof"`
+	}
+	type args struct {
+		src interface{}
+	}
+	type matchTest struct {
+		name      string
+		args      args
+		want      Matcher
+		wantPanic bool
+	}
+	defaultTests := []matchTest{
+		{
+			name: "base case - string",
+			args: args{
+				src: "string",
+			},
+			want: Like("string"),
+		},
+		{
+			name: "base case - bool",
+			args: args{
+				src: true,
+			},
+			want: Like(true),
+		},
+		{
+			name: "base case - int",
+			args: args{
+				src: 1,
+			},
+			want: Like(1),
+		},
+		{
+			name: "base case - uint",
+			args: args{
+				src: uint(1),
+			},
+			want: Like(1),
+		},
+		{
+			name: "base case - float32",
+			args: args{
+				src: float32(1),
+			},
+			want: Like(1.1),
+		},
+		{
+			name: "error - unhandled type",
+			args: args{
+				src: make(map[string]string),
+			},
+			wantPanic: true,
+		},
+	}
+
+	matchV2ProtoTests := append(defaultTests, matchTest{
+		name: "structs mixed for compatibility with proto3 and json types",
+		args: args{
+			src: mixedDTO{},
+		},
+		want: StructMatcher{
+			"onlyJsonTag":         Like("string"),
+			"bothNameFromJsonTag": Like(1),
+			"onlyProtobufTag":     StructMatcher{"onlyJsonTagNested": Like("string")},
+		},
+	})
+	customMatcher := matchers.NewCustomMatchStructV2(matchers.CustomMatchStructV2Args{StrategyFunc: protoJsonFieldStrategyFunc})
+	for _, tt := range matchV2ProtoTests {
+		t.Run(tt.name, func(t *testing.T) {
+			var got Matcher
+			var didPanic bool
+			defer func() {
+				if rec := recover(); rec != nil {
+					fmt.Println(rec)
+					didPanic = true
+				}
+				if tt.wantPanic != didPanic {
+					t.Errorf("Match() - '%s': didPanic = %v, want %v", tt.name, didPanic, tt.wantPanic)
+				} else if !didPanic && !reflect.DeepEqual(got, tt.want) {
+					t.Errorf("Match() - '%s':  = %v, want %v", tt.name, got, tt.want)
+				}
+			}()
+
+			got = customMatcher.MatchV2(tt.args.src)
+			log.Println("Got matcher: ", got)
+		})
+	}
+}
+
+// ProtoJsonFieldStrategyFunc provides an example to extend the matchers.CustomMatchStructV2Args.Match
+// extension allows for parsing of custom structs tags, and this example demonstrates a
+// potential solution relating to protojson
+var protoJsonFieldStrategyFunc = func(field reflect.StructField) matchers.FieldMatchArgs {
+	if fieldName, enum := fieldNameByTagStrategy(field); enum != "" {
+		var pactTag string
+		if _, ok := field.Tag.Lookup("pact"); ok {
+			pactTag = field.Tag.Get("pact")
+		} else {
+			pactTag = generateDefaultTagForEnum(enum)
+		}
+		return matchers.FieldMatchArgs{Name: fieldName, MatchType: reflect.TypeOf("string"), PactTag: pactTag}
+	} else if fieldName != "" {
+		return matchers.FieldMatchArgs{Name: fieldName, MatchType: field.Type, PactTag: field.Tag.Get("pact")}
+	} else {
+		return matchers.DefaultFieldStrategyFunc(field)
+	}
+}
+
+func fieldNameByTagStrategy(field reflect.StructField) (fieldName string, enum string) {
+	var v string
+	var ok bool
+	if v, ok = field.Tag.Lookup("protobuf"); ok {
+		arr := strings.Split(v, ",")
+		for i := 0; i < len(arr); i++ {
+			if strings.HasPrefix(arr[i], "json=") {
+				fieldName = strings.Split(arr[i], "=")[1]
+			}
+			if strings.HasPrefix(arr[i], "enum=") {
+				enum = strings.Split(arr[i], "=")[1]
+			}
+		}
+	}
+
+	if v, ok = field.Tag.Lookup("json"); ok {
+		fieldName = strings.Split(v, ",")[0]
+	}
+	return fieldName, enum
+}
+
+func generateDefaultTagForEnum(enum string) string {
+	var enumType protoreflect.EnumType
+	var err error
+	var example, regex string
+
+	if enumType, err = protoregistry.GlobalTypes.FindEnumByName(protoreflect.FullName(enum)); err != nil {
+		panic(errors.Wrapf(err, "could not find enum %s", enum))
+	}
+
+	values := enumType.Descriptor().Values()
+	enumNames := make([]string, 0)
+	for i := 0; i < values.Len(); i++ {
+		enumNames = append(enumNames, fmt.Sprintf("%s", values.Get(i).Name()))
+	}
+	if len(enumNames) > 0 {
+		example = enumNames[0]
+	}
+	regex = strings.Join(enumNames, "|")
+	return fmt.Sprintf("example=%s,regex=^(%s)$", example, regex)
+}

go.mod

@@ -15,6 +15,7 @@ require (
 	github.com/hashicorp/logutils v1.0.0
 	github.com/klauspost/compress v1.15.4 // indirect
 	github.com/mitchellh/go-testing-interface v1.14.1 // indirect
+	github.com/pkg/errors v0.9.1
 	github.com/spf13/afero v1.6.0
 	github.com/spf13/cobra v1.1.3
 	github.com/stretchr/testify v1.7.0

go.sum

@@ -305,6 +305,7 @@ github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FI
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=

matchers/ext.go

@@ -0,0 +1,19 @@
+package matchers
+
+import "reflect"
+
+type CustomMatchStructV2Args struct {
+	StrategyFunc FieldStrategyFunc
+}
+
+type customMatchStructV2 struct {
+	matchStruct matchStructV2
+}
+
+func NewCustomMatchStructV2(args CustomMatchStructV2Args) customMatchStructV2 {
+	return customMatchStructV2{matchStruct: matchStructV2{args.StrategyFunc}}
+}
+
+func (m *customMatchStructV2) MatchV2(src interface{}) Matcher {
+	return m.matchStruct.match(reflect.TypeOf(src), getDefaults())
+}

matchers/matcher.go

@@ -289,6 +289,26 @@ func objectToString(obj interface{}) string {
 	}
 }
 
+type FieldMatchArgs struct {
+	Name      string
+	MatchType reflect.Type
+	PactTag   string
+}
+type FieldStrategyFunc func(field reflect.StructField) FieldMatchArgs
+
+var DefaultFieldStrategyFunc = func(field reflect.StructField) FieldMatchArgs {
+	var v, fieldName string
+	var ok bool
+	if v, ok = field.Tag.Lookup("json"); ok {
+		fieldName = strings.Split(v, ",")[0]
+	}
+	return FieldMatchArgs{fieldName, field.Type, field.Tag.Get("pact")}
+}
+
+type matchStructV2 struct {
+	FieldStrategyFunc FieldStrategyFunc
+}
+
 // Match recursively traverses the provided type and outputs a
 // matcher string for it that is compatible with the Pact dsl.
 // By default, it requires slices to have a minimum of 1 element.
@@ -300,23 +320,28 @@ func objectToString(obj interface{}) string {
 // Minimum Slice Size: `pact:"min=2"`
 // String RegEx:       `pact:"example=2000-01-01,regex=^\\d{4}-\\d{2}-\\d{2}$"`
 func MatchV2(src interface{}) Matcher {
-	return match(reflect.TypeOf(src), getDefaults())
+	m := &matchStructV2{FieldStrategyFunc: DefaultFieldStrategyFunc}
+	return m.match(reflect.TypeOf(src), getDefaults())
 }
 
 // match recursively traverses the provided type and outputs a
 // matcher string for it that is compatible with the Pact dsl.
-func match(srcType reflect.Type, params params) Matcher {
+func (m *matchStructV2) match(srcType reflect.Type, params params) Matcher {
 	switch kind := srcType.Kind(); kind {
 	case reflect.Ptr:
-		return match(srcType.Elem(), params)
+		return m.match(srcType.Elem(), params)
 	case reflect.Slice, reflect.Array:
-		return EachLike(match(srcType.Elem(), getDefaults()), params.slice.min)
+		return EachLike(m.match(srcType.Elem(), getDefaults()), params.slice.min)
 	case reflect.Struct:
 		result := StructMatcher{}
 
 		for i := 0; i < srcType.NumField(); i++ {
 			field := srcType.Field(i)
-			result[strings.Split(field.Tag.Get("json"), ",")[0]] = match(field.Type, pluckParams(field.Type, field.Tag.Get("pact")))
+			args := m.FieldStrategyFunc(field)
+			if args.Name == "" {
+				continue
+			}
+			result[args.Name] = m.match(args.MatchType, pluckParams(args.MatchType, args.PactTag))
 		}
 		return result
 	case reflect.String: