Golang JSON模式匹配测试插件库gomatch的使用

gomatch是一个用于Go语言的JSON模式匹配库，它允许你定义JSON模式并验证JSON文档是否符合该模式。这个库在测试场景中特别有用，可以验证API响应是否符合预期的结构。

安装gomatch

go get github.com/gomatch/match

基本用法

1. 简单匹配

package main

import (
	"fmt"
	"encoding/json"
	"github.com/gomatch/match"
)

func main() {
	// 定义JSON模式
	pattern := `{
		"name": "string",
		"age": "number",
		"active": "boolean"
	}`

	// 要测试的JSON数据
	data := `{
		"name": "John Doe",
		"age": 30,
		"active": true
	}`

	// 解析模式
	matcher, err := match.NewJSONMatcher(pattern)
	if err != nil {
		panic(err)
	}

	// 匹配数据
	var jsonData interface{}
	if err := json.Unmarshal([]byte(data), &jsonData); err != nil {
		panic(err)
	}

	if ok, err := matcher.Match(jsonData); ok {
		fmt.Println("JSON数据匹配模式")
	} else {
		fmt.Printf("不匹配: %v\n", err)
	}
}

2. 高级模式匹配

gomatch支持更复杂的模式匹配：

package main

import (
	"fmt"
	"encoding/json"
	"github.com/gomatch/match"
)

func main() {
	// 更复杂的模式
	pattern := `{
		"id": "number",
		"username": "string",
		"email": "string?",
		"roles": ["string+"],
		"metadata": {
			"createdAt": "string",
			"updatedAt": "string?"
		},
		"*": "*"
	}`

	data := `{
		"id": 123,
		"username": "johndoe",
		"roles": ["admin", "user"],
		"metadata": {
			"createdAt": "2023-01-01",
			"updatedAt": "2023-01-02"
		},
		"extraField": "value"
	}`

	matcher, err := match.NewJSONMatcher(pattern)
	if err != nil {
		panic(err)
	}

	var jsonData interface{}
	if err := json.Unmarshal([]byte(data), &jsonData); err != nil {
		panic(err)
	}

	if ok, err := matcher.Match(jsonData); ok {
		fmt.Println("匹配成功")
	} else {
		fmt.Printf("匹配失败: %v\n", err)
	}
}

模式语法说明

gomatch支持以下模式语法：

1. 基本类型：

   • "string" - 字符串
   • "number" - 数字
   • "boolean" - 布尔值
   • "null" - null值
   • "*" - 任意类型

2. 可选字段：

   • 在类型后加?表示可选，如"string?"

3. 数组：

   • ["type"] - 元素为指定类型的数组
   • ["type+"] - 至少有一个元素的数组
   • ["type?"] - 可能为空的数组

4. 对象：

   • {"field": "type"} - 指定字段和类型
   • {"*": "*"} - 允许任意额外字段

在测试中使用gomatch

在单元测试中，gomatch特别有用：

package main

import (
	"testing"
	"encoding/json"
	"github.com/gomatch/match"
	"github.com/stretchr/testify/assert"
)

func TestAPIResponse(t *testing.T) {
	// 模拟API响应
	apiResponse := `{
		"status": "success",
		"data": {
			"users": [
				{
					"id": 1,
					"name": "Alice"
				},
				{
					"id": 2,
					"name": "Bob"
				}
			],
			"count": 2
		}
	}`

	// 定义期望的模式
	pattern := `{
		"status": "string",
		"data": {
			"users": [{
				"id": "number",
				"name": "string"
			}+],
			"count": "number"
		}
	}`

	matcher, err := match.NewJSONMatcher(pattern)
	assert.NoError(t, err)

	var responseData interface{}
	err = json.Unmarshal([]byte(apiResponse), &responseData)
	assert.NoError(t, err)

	ok, err := matcher.Match(responseData)
	assert.True(t, ok, "API响应不匹配期望的模式: %v", err)
}

自定义匹配器

gomatch还允许你创建自定义匹配器：

package main

import (
	"fmt"
	"github.com/gomatch/match"
	"regexp"
)

type regexMatcher struct {
	pattern *regexp.Regexp
}

func (m *regexMatcher) Match(value interface{}) (bool, error) {
	s, ok := value.(string)
	if !ok {
		return false, nil
	}
	return m.pattern.MatchString(s), nil
}

func main() {
	// 注册自定义匹配器
	match.RegisterMatcher("email", func(arg string) (match.Matcher, error) {
		return &regexMatcher{
			pattern: regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`),
		}, nil
	})

	// 使用自定义匹配器
	pattern := `{
		"name": "string",
		"email": "email"
	}`

	data := `{
		"name": "John Doe",
		"email": "john@example.com"
	}`

	matcher, err := match.NewJSONMatcher(pattern)
	if err != nil {
		panic(err)
	}

	var jsonData interface{}
	if err := json.Unmarshal([]byte(data), &jsonData); err != nil {
		panic(err)
	}

	if ok, err := matcher.Match(jsonData); ok {
		fmt.Println("匹配成功")
	} else {
		fmt.Printf("匹配失败: %v\n", err)
	}
}

总结

gomatch是一个强大的JSON模式匹配库，特别适合在测试API响应时使用。它提供了：

1. 简洁的模式定义语法
2. 灵活的类型匹配
3. 可选字段支持
4. 数组和对象的复杂匹配
5. 自定义匹配器扩展

通过使用gomatch，你可以确保你的JSON数据结构符合预期，而无需编写冗长的结构体比较代码。