validator/run_test.go

// Package validator ...
//
// Description : validator ...
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 2024-04-29 14:14
package validator

import (
	"fmt"
	"git.zhangdeman.cn/gateway/validator/define"
	"git.zhangdeman.cn/zhangdeman/consts"
	"github.com/stretchr/testify/assert"
	"testing"
)

// TestRunString 测试字符串类型
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 16:48 2024/11/1
func TestRunString(t *testing.T) {
	sourceData := map[string]interface{}{
		"name": "白茶清欢",
	}
	ruleListForNotFound := []*define.FieldRule{
		&define.FieldRule{
			Path:                   "name1",
			Type:                   "string",
			DisableRewrite:         false,
			DefaultValue:           nil,
			IsRequired:             true,
			AllowEmpty:             false,
			AllowZero:              false,
			AllowNil:               false,
			DisableAutoTrimSpace:   false,
			DisableAutoConvert:     false,
			RequiredConditionGroup: nil,
			ValueLimit:             nil,
			SliceConfig:            nil,
			MapConfig:              nil,
		},
	}
	err := Run(sourceData, ruleListForNotFound, nil)
	if nil != err {
		fmt.Println(err.Error())
	}
	assert.Error(t, err)

	sourceData = map[string]interface{}{
		"name": "",
	}
	ruleListForEmpty := []*define.FieldRule{
		&define.FieldRule{
			Path:                 "name",
			Type:                 "string",
			DisableRewrite:       false,
			DefaultValue:         nil,
			IsRequired:           true,
			AllowEmpty:           false,
			AllowZero:            false,
			AllowNil:             false,
			DisableAutoTrimSpace: false,
			DisableAutoConvert:   false,
		},
	}

	err = Run(sourceData, ruleListForEmpty, nil)
	if nil != err {
		fmt.Println(err.Error())
	}
	assert.Error(t, err)

	sourceData = map[string]interface{}{
		"name": 18,
	}
	ruleListForDisableAutoConvert := []*define.FieldRule{
		&define.FieldRule{
			Path:                 "name",
			Type:                 "string",
			DisableRewrite:       false,
			DefaultValue:         nil,
			IsRequired:           true,
			AllowEmpty:           false,
			AllowZero:            false,
			AllowNil:             false,
			DisableAutoTrimSpace: false,
			DisableAutoConvert:   true,
		},
	}
	err = Run(sourceData, ruleListForDisableAutoConvert, nil)
	if nil != err {
		fmt.Println(err.Error())
	}
	assert.Error(t, err)

	sourceData = map[string]interface{}{
		"name": " ",
	}
	ruleListForAllowTrim := []*define.FieldRule{
		&define.FieldRule{
			Path:                 "name",
			Type:                 "string",
			DisableRewrite:       false,
			DefaultValue:         nil,
			IsRequired:           true,
			AllowEmpty:           false,
			AllowZero:            false,
			AllowNil:             false,
			DisableAutoTrimSpace: false,
			DisableAutoConvert:   true,
		},
	}
	err = Run(sourceData, ruleListForAllowTrim, nil)
	if nil != err {
		fmt.Println(err.Error())
	}
	assert.Error(t, err)

	sourceData = map[string]interface{}{
		"name": " ",
	}
	ruleListForDisableTrim := []*define.FieldRule{
		&define.FieldRule{
			Path:                 "name",
			Type:                 "string",
			DisableRewrite:       false,
			DefaultValue:         nil,
			IsRequired:           true,
			AllowEmpty:           false,
			AllowZero:            false,
			AllowNil:             false,
			DisableAutoTrimSpace: true,
			DisableAutoConvert:   true,
		},
	}
	err = Run(sourceData, ruleListForDisableTrim, nil)
	if nil != err {
		fmt.Println(err.Error())
	}
}

// TestRunFieldDepend 测试字段依赖关系
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 18:40 2024/11/1
func TestRunFieldDepend(t *testing.T) {
	sourceData := map[string]interface{}{
		"name": "",
	}
	ruleListForDepend := []*define.FieldRule{
		&define.FieldRule{
			Path:                 "name",
			Type:                 "string",
			DisableRewrite:       false,
			DefaultValue:         nil,
			IsRequired:           false,
			AllowEmpty:           false,
			AllowZero:            false,
			AllowNil:             false,
			DisableAutoTrimSpace: false,
			DisableAutoConvert:   false,
			RequiredConditionGroup: [][]define.RequiredCondition{
				[]define.RequiredCondition{
					define.RequiredCondition{
						DependOnField:       "age",
						DependOnFieldType:   "int",
						DependOnFieldStatus: []string{consts.DataStatusIsEmpty, consts.DataStatusIsNil},
					},
				},
			},
			ValueLimit:  nil,
			SliceConfig: nil,
			MapConfig:   nil,
		},
	}
	err := Run(sourceData, ruleListForDepend, nil)
	if nil != err {
		fmt.Println(err.Error())
	}
	assert.Error(t, err)
}