bingyi/gf
1
0
Fork 0
mirror of https://gitee.com/johng/gf synced 2026-06-06 02:25:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

add context for package gvalid.Check* functions

Browse Source
This commit is contained in:
John Guo
2021-05-13 20:56:52 +08:00
parent 23110b5d19
commit cc1224e032
20 changed files with 320 additions and 298 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.example/net/ghttp/server/request/request_validation.go
View File

@ -18,13 +18,13 @@ func main() {
s.Group("/", func(rgroup *ghttp.RouterGroup) {
rgroup.ALL("/user", func(r *ghttp.Request) {
user := new(User)
if err := r.GetToStruct(user); err != nil {
if err := r.GetStruct(user); err != nil {
r.Response.WriteJsonExit(g.Map{
"message": err,
"errcode": 1,
})
}
if err := gvalid.CheckStruct(user, nil); err != nil {
if err := gvalid.CheckStruct(r.Context(), user, nil); err != nil {
r.Response.WriteJsonExit(g.Map{
"message": err.Maps(),
"errcode": 1,

15
.example/util/gvalid/gvalid.go
View File

@ -1,31 +1,32 @@
package main
import (
"context"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/util/gvalid"
)
func main() {
//rule := "length:6,16"
//if m := gvalid.Check("123456", rule, nil); m != nil {
//if m := gvalid.Check(context.TODO(), "123456", rule, nil); m != nil {
// fmt.Println(m)
//}
//if m := gvalid.Check("12345", rule, nil); m != nil {
//if m := gvalid.Check(context.TODO(), "12345", rule, nil); m != nil {
// fmt.Println(m)
// // map[length:字段长度为6到16个字符]
//}
//rule := "integer|between:6,16"
//msgs := "请输入一个整数|参数大小不对啊老铁"
//fmt.Println(gvalid.Check("5.66", rule, msgs))
//fmt.Println(gvalid.Check(context.TODO(), "5.66", rule, msgs))
//// map[integer:请输入一个整数 between:参数大小不对啊老铁]
//// 参数长度至少为6个数字或者6个字母，但是总长度不能超过16个字符
//rule := `regex:\d{6,}|\D{6,}|max-length:16`
//if m := gvalid.Check("123456", rule, nil); m != nil {
//if m := gvalid.Check(context.TODO(), "123456", rule, nil); m != nil {
// fmt.Println(m)
//}
//if m := gvalid.Check("abcde6", rule, nil); m != nil {
//if m := gvalid.Check(context.TODO(), "abcde6", rule, nil); m != nil {
// fmt.Println(m)
// // map[regex:字段值不合法]
//}
@ -40,7 +41,7 @@ func main() {
// "password" : "required|length:6,16|same:password2",
// "password2" : "required|length:6,16",
//}
//fmt.Println(gvalid.CheckMap(params, rules))
//fmt.Println(gvalid.CheckMap(context.TODO(), params, rules))
//// map[passport:map[length:字段长度为6到16个字符] password:map[same:字段值不合法]]
params := map[string]interface{}{
@ -60,7 +61,7 @@ func main() {
"same": "两次密码输入不相等",
},
}
if e := gvalid.CheckMap(params, rules, msgs); e != nil {
if e := gvalid.CheckMap(context.TODO(), params, rules, msgs); e != nil {
g.Dump(e.Maps())
}
// map[passport:map[length:账号长度应当在6到16之间] password:map[same:两次密码输入不相等]]

3
.example/util/gvalid/gvalid_custom_message.go
View File

@ -1,6 +1,7 @@
package main
import (
"context"
"fmt"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/util/gvalid"
@ -8,6 +9,6 @@ import (
func main() {
g.I18n().SetLanguage("cn")
err := gvalid.Check("", "required", nil)
err := gvalid.Check(context.TODO(), "", "required", nil)
fmt.Println(err.String())
}

3
.example/util/gvalid/gvalid_error.go
View File

@ -1,6 +1,7 @@
package main
import (
"context"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/util/gvalid"
)
@ -17,7 +18,7 @@ func main() {
ConfiemPassword: "",
}
e := gvalid.CheckStruct(user, nil)
e := gvalid.CheckStruct(context.TODO(), user, nil)
g.Dump(e.Map())
g.Dump(e.Maps())
g.Dump(e.String())

3
.example/util/gvalid/gvalid_result.go
View File

@ -1,6 +1,7 @@
package main
import (
"context"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/util/gvalid"
)
@ -18,7 +19,7 @@ func main() {
Pass2: "123",
}
e := gvalid.CheckStruct(user, nil)
e := gvalid.CheckStruct(context.TODO(), user, nil)
g.Dump(e.String())
g.Dump(e.FirstString())
}

3
.example/util/gvalid/gvalid_sequence.go
View File

@ -1,6 +1,7 @@
package main
import (
"context"
"fmt"
"github.com/gogf/gf/util/gvalid"
@ -17,7 +18,7 @@ func main() {
"password@required|length:6,16|same:password2#密码不能为空}|两次密码输入不相等",
"password2@required|length:6,16#",
}
if e := gvalid.CheckMap(params, rules); e != nil {
if e := gvalid.CheckMap(context.TODO(), params, rules); e != nil {
fmt.Println(e.Map())
fmt.Println(e.FirstItem())
fmt.Println(e.FirstString())

5
.example/util/gvalid/gvalid_struct1.go
View File

@ -1,6 +1,7 @@
package main
import (
"context"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/util/gvalid"
)
@ -20,7 +21,7 @@ func main() {
}
// 使用结构体定义的校验规则和错误提示进行校验
g.Dump(gvalid.CheckStruct(user, nil).Map())
g.Dump(gvalid.CheckStruct(context.TODO(), user, nil).Map())
// 自定义校验规则和错误提示，对定义的特定校验规则和错误提示进行覆盖
rules := map[string]string{
@ -31,5 +32,5 @@ func main() {
"password3": "名称不能为空",
},
}
g.Dump(gvalid.CheckStruct(user, rules, msgs).Map())
g.Dump(gvalid.CheckStruct(context.TODO(), user, rules, msgs).Map())
}

3
.example/util/gvalid/gvalid_struct2.go
View File

@ -1,6 +1,7 @@
package main
import (
"context"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/util/gvalid"
)
@ -13,5 +14,5 @@ func main() {
user := &User{}
g.Dump(gvalid.CheckStruct(user, nil))
g.Dump(gvalid.CheckStruct(context.TODO(), user, nil))
}

3
.example/util/gvalid/gvalid_struct3.go
View File

@ -1,6 +1,7 @@
package main
import (
"context"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/util/gvalid"
)
@ -15,5 +16,5 @@ func main() {
Pass: "1",
}
g.Dump(gvalid.CheckStruct(user, nil).Maps())
g.Dump(gvalid.CheckStruct(context.TODO(), user, nil).Maps())
}

6
i18n/gi18n/gi18n_ctx.go
View File

@ -15,12 +15,18 @@ const (
// WithLanguage append language setting to the context and returns a new context.
func WithLanguage(ctx context.Context, language string) context.Context {
if ctx == nil {
ctx = context.TODO()
}
return context.WithValue(ctx, ctxLanguage, language)
}
// LanguageFromCtx retrieves and returns language name from context.
// It returns an empty string if it is not set previously.
func LanguageFromCtx(ctx context.Context) string {
if ctx == nil {
return ""
}
v := ctx.Value(ctxLanguage)
if v != nil {
return v.(string)

3
net/ghttp/ghttp_request_param.go
View File

@ -102,7 +102,7 @@ func (r *Request) doParse(pointer interface{}, requestType int) error {
}
}
// Validation.
if err := gvalid.CheckStructWithParamMap(pointer, data, nil); err != nil {
if err := gvalid.CheckStructWithParamMap(r.Context(), pointer, data, nil); err != nil {
return err
}
@ -120,6 +120,7 @@ func (r *Request) doParse(pointer interface{}, requestType int) error {
}
for i := 0; i < reflectVal2.Len(); i++ {
if err := gvalid.CheckStructWithParamMap(
r.Context(),
reflectVal2.Index(i),
j.GetMap(gconv.String(i)),
nil,

2
net/ghttp/ghttp_unit_request_struct_test.go
View File

@ -425,7 +425,7 @@ func Test_Params_Struct(t *testing.T) {
if err := r.GetStruct(user); err != nil {
r.Response.WriteExit(err)
}
if err := gvalid.CheckStruct(user, nil); err != nil {
if err := gvalid.CheckStruct(r.Context(), user, nil); err != nil {
r.Response.WriteExit(err)
}
}

17
util/gvalid/gvalid.go
View File

@ -8,6 +8,7 @@
package gvalid
import (
"context"
"regexp"
"strings"
@ -170,8 +171,8 @@ var (
// string/map/struct/*struct.
// The optional parameter `params` specifies the extra validation parameters for some rules
// like: required-*、same、different, etc.
func Check(value interface{}, rules string, messages interface{}, params ...interface{}) *Error {
return defaultValidator.Check(value, rules, messages, params...)
func Check(ctx context.Context, value interface{}, rules string, messages interface{}, params ...interface{}) *Error {
return defaultValidator.Ctx(ctx).Check(value, rules, messages, params...)
}
// CheckMap validates map and returns the error result. It returns nil if with successful validation.
@ -179,8 +180,8 @@ func Check(value interface{}, rules string, messages interface{}, params ...inte
// The parameter `rules` can be type of []string/map[string]string. It supports sequence in error result
// if `rules` is type of []string.
// The optional parameter `messages` specifies the custom error messages for specified keys and rules.
func CheckMap(params interface{}, rules interface{}, messages ...CustomMsg) *Error {
return defaultValidator.CheckMap(params, rules, messages...)
func CheckMap(ctx context.Context, params interface{}, rules interface{}, messages ...CustomMsg) *Error {
return defaultValidator.Ctx(ctx).CheckMap(params, rules, messages...)
}
// CheckStruct validates strcut and returns the error result.
@ -189,8 +190,8 @@ func CheckMap(params interface{}, rules interface{}, messages ...CustomMsg) *Err
// The parameter `rules` can be type of []string/map[string]string. It supports sequence in error result
// if `rules` is type of []string.
// The optional parameter `messages` specifies the custom error messages for specified keys and rules.
func CheckStruct(object interface{}, rules interface{}, messages ...CustomMsg) *Error {
return defaultValidator.CheckStruct(object, rules, messages...)
func CheckStruct(ctx context.Context, object interface{}, rules interface{}, messages ...CustomMsg) *Error {
return defaultValidator.Ctx(ctx).CheckStruct(object, rules, messages...)
}
// CheckStructWithParamMap validates struct with given parameter map and returns the error result.
@ -199,8 +200,8 @@ func CheckStruct(object interface{}, rules interface{}, messages ...CustomMsg) *
// The parameter `rules` can be type of []string/map[string]string. It supports sequence in error result
// if `rules` is type of []string.
// The optional parameter `messages` specifies the custom error messages for specified keys and rules.
func CheckStructWithParamMap(object interface{}, paramMap interface{}, rules interface{}, messages ...CustomMsg) *Error {
return defaultValidator.CheckStructWithParamMap(object, paramMap, rules, messages...)
func CheckStructWithParamMap(ctx context.Context, object interface{}, paramMap interface{}, rules interface{}, messages ...CustomMsg) *Error {
return defaultValidator.Ctx(ctx).CheckStructWithParamMap(object, paramMap, rules, messages...)
}
// parseSequenceTag parses one sequence tag to field, rule and error message.

4
util/gvalid/gvalid_validator.go
View File

@ -21,8 +21,8 @@ type Validator struct {
// New creates and returns a new Validator.
func New() *Validator {
return &Validator{
ctx: context.TODO(),
i18nManager: gi18n.Instance(),
ctx: context.TODO(), // Initialize an empty context.
i18nManager: gi18n.Instance(), // Use default i18n manager.
}
}

25
util/gvalid/gvalid_z_example_test.go
View File

@ -7,6 +7,7 @@
package gvalid_test
import (
"context"
"errors"
"fmt"
"github.com/gogf/gf/container/gvar"
@ -28,7 +29,7 @@ func ExampleCheckMap() {
"password@required|length:6,16|same:password2#密码不能为空|密码长度应当在:min到:max之间|两次密码输入不相等",
"password2@required|length:6,16#",
}
if e := gvalid.CheckMap(params, rules); e != nil {
if e := gvalid.CheckMap(context.TODO(), params, rules); e != nil {
fmt.Println(e.Map())
fmt.Println(e.FirstItem())
fmt.Println(e.FirstString())
@ -50,7 +51,7 @@ func ExampleCheckMap2() {
"password@required|length:6,16|same:password2#密码不能为空|密码长度应当在:min到:max之间|两次密码输入不相等",
"password2@required|length:6,16#",
}
if e := gvalid.CheckMap(params, rules); e != nil {
if e := gvalid.CheckMap(context.TODO(), params, rules); e != nil {
fmt.Println(e.Map())
fmt.Println(e.FirstItem())
fmt.Println(e.FirstString())
@ -72,7 +73,7 @@ func ExampleCheckStruct() {
Page: 1,
Size: 10,
}
err := gvalid.CheckStruct(obj, nil)
err := gvalid.CheckStruct(context.TODO(), obj, nil)
fmt.Println(err == nil)
// Output:
// true
@ -89,7 +90,7 @@ func ExampleCheckStruct2() {
Page: 1,
Size: 10,
}
err := gvalid.CheckStruct(obj, nil)
err := gvalid.CheckStruct(context.TODO(), obj, nil)
fmt.Println(err == nil)
// Output:
// true
@ -106,7 +107,7 @@ func ExampleCheckStruct3() {
Page: 1,
Size: 10,
}
err := gvalid.CheckStruct(obj, nil)
err := gvalid.CheckStruct(context.TODO(), obj, nil)
fmt.Println(err)
// Output:
// project id must between 1, 10000
@ -138,7 +139,7 @@ func ExampleRegisterRule() {
Name: "john",
Pass: "123456",
}
err := gvalid.CheckStruct(user, nil)
err := gvalid.CheckStruct(context.TODO(), user, nil)
fmt.Println(err.Error())
// May Output:
// 用户名称已被占用
@ -172,14 +173,14 @@ func ExampleRegisterRule_OverwriteRequired() {
}
return nil
})
fmt.Println(gvalid.Check("", "required", "It's required"))
fmt.Println(gvalid.Check(0, "required", "It's required"))
fmt.Println(gvalid.Check(false, "required", "It's required"))
fmt.Println(gvalid.Check(context.TODO(), "", "required", "It's required"))
fmt.Println(gvalid.Check(context.TODO(), 0, "required", "It's required"))
fmt.Println(gvalid.Check(context.TODO(), false, "required", "It's required"))
gvalid.DeleteRule(rule)
fmt.Println("rule deleted")
fmt.Println(gvalid.Check("", "required", "It's required"))
fmt.Println(gvalid.Check(0, "required", "It's required"))
fmt.Println(gvalid.Check(false, "required", "It's required"))
fmt.Println(gvalid.Check(context.TODO(), "", "required", "It's required"))
fmt.Println(gvalid.Check(context.TODO(), 0, "required", "It's required"))
fmt.Println(gvalid.Check(context.TODO(), false, "required", "It's required"))
// Output:
// It's required
// It's required

415
util/gvalid/gvalid_z_unit_basic_all_test.go
View File

@ -7,6 +7,7 @@
package gvalid_test
import (
"context"
"github.com/gogf/gf/errors/gerror"
"github.com/gogf/gf/os/gtime"
"testing"
@ -23,9 +24,9 @@ func Test_Check(t *testing.T) {
val1 := 0
val2 := 7
val3 := 20
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
t.Assert(err1, "invalid_rules: abc:6,16")
t.Assert(err2, "invalid_rules: abc:6,16")
t.Assert(err3, "invalid_rules: abc:6,16")
@ -33,16 +34,16 @@ func Test_Check(t *testing.T) {
}
func Test_Required(t *testing.T) {
if m := gvalid.Check("1", "required", nil); m != nil {
if m := gvalid.Check(context.TODO(), "1", "required", nil); m != nil {
t.Error(m)
}
if m := gvalid.Check("", "required", nil); m == nil {
if m := gvalid.Check(context.TODO(), "", "required", nil); m == nil {
t.Error(m)
}
if m := gvalid.Check("", "required-if: id,1,age,18", nil, map[string]interface{}{"id": 1, "age": 19}); m == nil {
if m := gvalid.Check(context.TODO(), "", "required-if: id,1,age,18", nil, map[string]interface{}{"id": 1, "age": 19}); m == nil {
t.Error("Required校验失败")
}
if m := gvalid.Check("", "required-if: id,1,age,18", nil, map[string]interface{}{"id": 2, "age": 19}); m != nil {
if m := gvalid.Check(context.TODO(), "", "required-if: id,1,age,18", nil, map[string]interface{}{"id": 2, "age": 19}); m != nil {
t.Error("Required校验失败")
}
}
@ -50,20 +51,20 @@ func Test_Required(t *testing.T) {
func Test_RequiredIf(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
rule := "required-if:id,1,age,18"
t.AssertNE(gvalid.Check("", rule, nil, g.Map{"id": 1}), nil)
t.Assert(gvalid.Check("", rule, nil, g.Map{"id": 0}), nil)
t.AssertNE(gvalid.Check("", rule, nil, g.Map{"age": 18}), nil)
t.Assert(gvalid.Check("", rule, nil, g.Map{"age": 20}), nil)
t.AssertNE(gvalid.Check(context.TODO(), "", rule, nil, g.Map{"id": 1}), nil)
t.Assert(gvalid.Check(context.TODO(), "", rule, nil, g.Map{"id": 0}), nil)
t.AssertNE(gvalid.Check(context.TODO(), "", rule, nil, g.Map{"age": 18}), nil)
t.Assert(gvalid.Check(context.TODO(), "", rule, nil, g.Map{"age": 20}), nil)
})
}
func Test_RequiredUnless(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
rule := "required-unless:id,1,age,18"
t.Assert(gvalid.Check("", rule, nil, g.Map{"id": 1}), nil)
t.AssertNE(gvalid.Check("", rule, nil, g.Map{"id": 0}), nil)
t.Assert(gvalid.Check("", rule, nil, g.Map{"age": 18}), nil)
t.AssertNE(gvalid.Check("", rule, nil, g.Map{"age": 20}), nil)
t.Assert(gvalid.Check(context.TODO(), "", rule, nil, g.Map{"id": 1}), nil)
t.AssertNE(gvalid.Check(context.TODO(), "", rule, nil, g.Map{"id": 0}), nil)
t.Assert(gvalid.Check(context.TODO(), "", rule, nil, g.Map{"age": 18}), nil)
t.AssertNE(gvalid.Check(context.TODO(), "", rule, nil, g.Map{"age": 20}), nil)
})
}
@ -81,9 +82,9 @@ func Test_RequiredWith(t *testing.T) {
"id": 100,
"name": "john",
}
err1 := gvalid.Check(val1, rule, nil, params1)
err2 := gvalid.Check(val1, rule, nil, params2)
err3 := gvalid.Check(val1, rule, nil, params3)
err1 := gvalid.Check(context.TODO(), val1, rule, nil, params1)
err2 := gvalid.Check(context.TODO(), val1, rule, nil, params2)
err3 := gvalid.Check(context.TODO(), val1, rule, nil, params3)
t.Assert(err1, nil)
t.AssertNE(err2, nil)
t.AssertNE(err3, nil)
@ -101,9 +102,9 @@ func Test_RequiredWith(t *testing.T) {
params3 := g.Map{
"time": time.Time{},
}
err1 := gvalid.Check(val1, rule, nil, params1)
err2 := gvalid.Check(val1, rule, nil, params2)
err3 := gvalid.Check(val1, rule, nil, params3)
err1 := gvalid.Check(context.TODO(), val1, rule, nil, params1)
err2 := gvalid.Check(context.TODO(), val1, rule, nil, params2)
err3 := gvalid.Check(context.TODO(), val1, rule, nil, params3)
t.Assert(err1, nil)
t.AssertNE(err2, nil)
t.Assert(err3, nil)
@ -120,9 +121,9 @@ func Test_RequiredWith(t *testing.T) {
params3 := g.Map{
"time": time.Now(),
}
err1 := gvalid.Check(val1, rule, nil, params1)
err2 := gvalid.Check(val1, rule, nil, params2)
err3 := gvalid.Check(val1, rule, nil, params3)
err1 := gvalid.Check(context.TODO(), val1, rule, nil, params1)
err2 := gvalid.Check(context.TODO(), val1, rule, nil, params2)
err3 := gvalid.Check(context.TODO(), val1, rule, nil, params3)
t.Assert(err1, nil)
t.AssertNE(err2, nil)
t.AssertNE(err3, nil)
@ -139,7 +140,7 @@ func Test_RequiredWith(t *testing.T) {
StartTime: nil,
EndTime: nil,
}
t.Assert(gvalid.CheckStruct(data, nil), nil)
t.Assert(gvalid.CheckStruct(context.TODO(), data, nil), nil)
})
gtest.C(t, func(t *gtest.T) {
type UserApiSearch struct {
@ -152,7 +153,7 @@ func Test_RequiredWith(t *testing.T) {
StartTime: nil,
EndTime: gtime.Now(),
}
t.AssertNE(gvalid.CheckStruct(data, nil), nil)
t.AssertNE(gvalid.CheckStruct(context.TODO(), data, nil), nil)
})
}
@ -170,9 +171,9 @@ func Test_RequiredWithAll(t *testing.T) {
"id": 100,
"name": "john",
}
err1 := gvalid.Check(val1, rule, nil, params1)
err2 := gvalid.Check(val1, rule, nil, params2)
err3 := gvalid.Check(val1, rule, nil, params3)
err1 := gvalid.Check(context.TODO(), val1, rule, nil, params1)
err2 := gvalid.Check(context.TODO(), val1, rule, nil, params2)
err3 := gvalid.Check(context.TODO(), val1, rule, nil, params3)
t.Assert(err1, nil)
t.Assert(err2, nil)
t.AssertNE(err3, nil)
@ -193,9 +194,9 @@ func Test_RequiredWithOut(t *testing.T) {
"id": 100,
"name": "john",
}
err1 := gvalid.Check(val1, rule, nil, params1)
err2 := gvalid.Check(val1, rule, nil, params2)
err3 := gvalid.Check(val1, rule, nil, params3)
err1 := gvalid.Check(context.TODO(), val1, rule, nil, params1)
err2 := gvalid.Check(context.TODO(), val1, rule, nil, params2)
err3 := gvalid.Check(context.TODO(), val1, rule, nil, params3)
t.AssertNE(err1, nil)
t.AssertNE(err2, nil)
t.Assert(err3, nil)
@ -216,9 +217,9 @@ func Test_RequiredWithOutAll(t *testing.T) {
"id": 100,
"name": "john",
}
err1 := gvalid.Check(val1, rule, nil, params1)
err2 := gvalid.Check(val1, rule, nil, params2)
err3 := gvalid.Check(val1, rule, nil, params3)
err1 := gvalid.Check(context.TODO(), val1, rule, nil, params1)
err2 := gvalid.Check(context.TODO(), val1, rule, nil, params2)
err3 := gvalid.Check(context.TODO(), val1, rule, nil, params3)
t.AssertNE(err1, nil)
t.Assert(err2, nil)
t.Assert(err3, nil)
@ -235,13 +236,13 @@ func Test_Date(t *testing.T) {
val5 := "2010.11.01"
val6 := "2010/11/01"
val7 := "2010=11=01"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err5 := gvalid.Check(val5, rule, nil)
err6 := gvalid.Check(val6, rule, nil)
err7 := gvalid.Check(val7, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
err5 := gvalid.Check(context.TODO(), val5, rule, nil)
err6 := gvalid.Check(context.TODO(), val6, rule, nil)
err7 := gvalid.Check(context.TODO(), val7, rule, nil)
t.Assert(err1, nil)
t.Assert(err2, nil)
t.Assert(err3, nil)
@ -260,12 +261,12 @@ func Test_DateFormat(t *testing.T) {
val4 := "201011-01"
val5 := "2010~11~01"
val6 := "2010-11~01"
err1 := gvalid.Check(val1, "date-format:Y", nil)
err2 := gvalid.Check(val2, "date-format:Ym", nil)
err3 := gvalid.Check(val3, "date-format:Y.m", nil)
err4 := gvalid.Check(val4, "date-format:Ym-d", nil)
err5 := gvalid.Check(val5, "date-format:Y~m~d", nil)
err6 := gvalid.Check(val6, "date-format:Y~m~d", nil)
err1 := gvalid.Check(context.TODO(), val1, "date-format:Y", nil)
err2 := gvalid.Check(context.TODO(), val2, "date-format:Ym", nil)
err3 := gvalid.Check(context.TODO(), val3, "date-format:Y.m", nil)
err4 := gvalid.Check(context.TODO(), val4, "date-format:Ym-d", nil)
err5 := gvalid.Check(context.TODO(), val5, "date-format:Y~m~d", nil)
err6 := gvalid.Check(context.TODO(), val6, "date-format:Y~m~d", nil)
t.Assert(err1, nil)
t.Assert(err2, nil)
t.Assert(err3, nil)
@ -276,8 +277,8 @@ func Test_DateFormat(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
t1 := gtime.Now()
t2 := time.Time{}
err1 := gvalid.Check(t1, "date-format:Y", nil)
err2 := gvalid.Check(t2, "date-format:Y", nil)
err1 := gvalid.Check(context.TODO(), t1, "date-format:Y", nil)
err2 := gvalid.Check(context.TODO(), t2, "date-format:Y", nil)
t.Assert(err1, nil)
t.AssertNE(err2, nil)
})
@ -290,10 +291,10 @@ func Test_Email(t *testing.T) {
value2 := "m@www@johngcn"
value3 := "m-m_m@mail.johng.cn"
value4 := "m.m-m@johng.cn"
err1 := gvalid.Check(value1, rule, nil)
err2 := gvalid.Check(value2, rule, nil)
err3 := gvalid.Check(value3, rule, nil)
err4 := gvalid.Check(value4, rule, nil)
err1 := gvalid.Check(context.TODO(), value1, rule, nil)
err2 := gvalid.Check(context.TODO(), value2, rule, nil)
err3 := gvalid.Check(context.TODO(), value3, rule, nil)
err4 := gvalid.Check(context.TODO(), value4, rule, nil)
t.AssertNE(err1, nil)
t.AssertNE(err2, nil)
t.Assert(err3, nil)
@ -303,10 +304,10 @@ func Test_Email(t *testing.T) {
func Test_Phone(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
err1 := gvalid.Check("1361990897", "phone", nil)
err2 := gvalid.Check("13619908979", "phone", nil)
err3 := gvalid.Check("16719908979", "phone", nil)
err4 := gvalid.Check("19719908989", "phone", nil)
err1 := gvalid.Check(context.TODO(), "1361990897", "phone", nil)
err2 := gvalid.Check(context.TODO(), "13619908979", "phone", nil)
err3 := gvalid.Check(context.TODO(), "16719908979", "phone", nil)
err4 := gvalid.Check(context.TODO(), "19719908989", "phone", nil)
t.AssertNE(err1.String(), nil)
t.Assert(err2, nil)
t.Assert(err3, nil)
@ -316,12 +317,12 @@ func Test_Phone(t *testing.T) {
func Test_PhoneLoose(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
err1 := gvalid.Check("13333333333", "phone-loose", nil)
err2 := gvalid.Check("15555555555", "phone-loose", nil)
err3 := gvalid.Check("16666666666", "phone-loose", nil)
err4 := gvalid.Check("23333333333", "phone-loose", nil)
err5 := gvalid.Check("1333333333", "phone-loose", nil)
err6 := gvalid.Check("10333333333", "phone-loose", nil)
err1 := gvalid.Check(context.TODO(), "13333333333", "phone-loose", nil)
err2 := gvalid.Check(context.TODO(), "15555555555", "phone-loose", nil)
err3 := gvalid.Check(context.TODO(), "16666666666", "phone-loose", nil)
err4 := gvalid.Check(context.TODO(), "23333333333", "phone-loose", nil)
err5 := gvalid.Check(context.TODO(), "1333333333", "phone-loose", nil)
err6 := gvalid.Check(context.TODO(), "10333333333", "phone-loose", nil)
t.Assert(err1, nil)
t.Assert(err2, nil)
t.Assert(err3, nil)
@ -338,11 +339,11 @@ func Test_Telephone(t *testing.T) {
val3 := "86292651"
val4 := "028-8692651"
val5 := "0830-8692651"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err5 := gvalid.Check(val5, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
err5 := gvalid.Check(context.TODO(), val5, rule, nil)
t.AssertNE(err1, nil)
t.AssertNE(err2, nil)
t.Assert(err3, nil)
@ -359,11 +360,11 @@ func Test_Passport(t *testing.T) {
val3 := "aaaaa"
val4 := "aaaaaa"
val5 := "a123_456"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err5 := gvalid.Check(val5, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
err5 := gvalid.Check(context.TODO(), val5, rule, nil)
t.AssertNE(err1, nil)
t.AssertNE(err2, nil)
t.AssertNE(err3, nil)
@ -380,11 +381,11 @@ func Test_Password(t *testing.T) {
val3 := "a12345-6"
val4 := ">,/;'[09-"
val5 := "a123_456"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err5 := gvalid.Check(val5, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
err5 := gvalid.Check(context.TODO(), val5, rule, nil)
t.AssertNE(err1, nil)
t.AssertNE(err2, nil)
t.Assert(err3, nil)
@ -403,13 +404,13 @@ func Test_Password2(t *testing.T) {
val5 := "a123_456"
val6 := "Nant1986"
val7 := "Nant1986!"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err5 := gvalid.Check(val5, rule, nil)
err6 := gvalid.Check(val6, rule, nil)
err7 := gvalid.Check(val7, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
err5 := gvalid.Check(context.TODO(), val5, rule, nil)
err6 := gvalid.Check(context.TODO(), val6, rule, nil)
err7 := gvalid.Check(context.TODO(), val7, rule, nil)
t.AssertNE(err1, nil)
t.AssertNE(err2, nil)
t.AssertNE(err3, nil)
@ -430,13 +431,13 @@ func Test_Password3(t *testing.T) {
val5 := "a123_456"
val6 := "Nant1986"
val7 := "Nant1986!"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err5 := gvalid.Check(val5, rule, nil)
err6 := gvalid.Check(val6, rule, nil)
err7 := gvalid.Check(val7, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
err5 := gvalid.Check(context.TODO(), val5, rule, nil)
err6 := gvalid.Check(context.TODO(), val6, rule, nil)
err7 := gvalid.Check(context.TODO(), val7, rule, nil)
t.AssertNE(err1, nil)
t.AssertNE(err2, nil)
t.AssertNE(err3, nil)
@ -452,8 +453,8 @@ func Test_Postcode(t *testing.T) {
rule := "postcode"
val1 := "12345"
val2 := "610036"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
t.AssertNE(err1, nil)
t.Assert(err2, nil)
})
@ -467,11 +468,11 @@ func Test_ResidentId(t *testing.T) {
val3 := "311128500121201"
val4 := "510521198607185367"
val5 := "51052119860718536x"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err5 := gvalid.Check(val5, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
err5 := gvalid.Check(context.TODO(), val5, rule, nil)
t.AssertNE(err1, nil)
t.AssertNE(err2, nil)
t.AssertNE(err3, nil)
@ -485,8 +486,8 @@ func Test_BankCard(t *testing.T) {
rule := "bank-card"
val1 := "6230514630000424470"
val2 := "6230514630000424473"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
t.AssertNE(err1, nil)
t.Assert(err2, nil)
})
@ -500,11 +501,11 @@ func Test_QQ(t *testing.T) {
val3 := "10000"
val4 := "38996181"
val5 := "389961817"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err5 := gvalid.Check(val5, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
err5 := gvalid.Check(context.TODO(), val5, rule, nil)
t.AssertNE(err1, nil)
t.AssertNE(err2, nil)
t.Assert(err3, nil)
@ -514,31 +515,31 @@ func Test_QQ(t *testing.T) {
}
func Test_Ip(t *testing.T) {
if m := gvalid.Check("10.0.0.1", "ip", nil); m != nil {
if m := gvalid.Check(context.TODO(), "10.0.0.1", "ip", nil); m != nil {
t.Error(m)
}
if m := gvalid.Check("10.0.0.1", "ipv4", nil); m != nil {
if m := gvalid.Check(context.TODO(), "10.0.0.1", "ipv4", nil); m != nil {
t.Error(m)
}
if m := gvalid.Check("0.0.0.0", "ipv4", nil); m != nil {
if m := gvalid.Check(context.TODO(), "0.0.0.0", "ipv4", nil); m != nil {
t.Error(m)
}
if m := gvalid.Check("1920.0.0.0", "ipv4", nil); m == nil {
if m := gvalid.Check(context.TODO(), "1920.0.0.0", "ipv4", nil); m == nil {
t.Error("ipv4校验失败")
}
if m := gvalid.Check("1920.0.0.0", "ip", nil); m == nil {
if m := gvalid.Check(context.TODO(), "1920.0.0.0", "ip", nil); m == nil {
t.Error("ipv4校验失败")
}
if m := gvalid.Check("fe80::5484:7aff:fefe:9799", "ipv6", nil); m != nil {
if m := gvalid.Check(context.TODO(), "fe80::5484:7aff:fefe:9799", "ipv6", nil); m != nil {
t.Error(m)
}
if m := gvalid.Check("fe80::5484:7aff:fefe:9799123", "ipv6", nil); m == nil {
if m := gvalid.Check(context.TODO(), "fe80::5484:7aff:fefe:9799123", "ipv6", nil); m == nil {
t.Error(m)
}
if m := gvalid.Check("fe80::5484:7aff:fefe:9799", "ip", nil); m != nil {
if m := gvalid.Check(context.TODO(), "fe80::5484:7aff:fefe:9799", "ip", nil); m != nil {
t.Error(m)
}
if m := gvalid.Check("fe80::5484:7aff:fefe:9799123", "ip", nil); m == nil {
if m := gvalid.Check(context.TODO(), "fe80::5484:7aff:fefe:9799123", "ip", nil); m == nil {
t.Error(m)
}
}
@ -551,11 +552,11 @@ func Test_IPv4(t *testing.T) {
val3 := "1.1.1.1"
val4 := "255.255.255.0"
val5 := "127.0.0.1"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err5 := gvalid.Check(val5, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
err5 := gvalid.Check(context.TODO(), val5, rule, nil)
t.AssertNE(err1, nil)
t.Assert(err2, nil)
t.Assert(err3, nil)
@ -572,11 +573,11 @@ func Test_IPv6(t *testing.T) {
val3 := "1030::C9B4:FF12:48AA:1A2B"
val4 := "2000:0:0:0:0:0:0:1"
val5 := "0000:0000:0000:0000:0000:ffff:c0a8:5909"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err5 := gvalid.Check(val5, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
err5 := gvalid.Check(context.TODO(), val5, rule, nil)
t.AssertNE(err1, nil)
t.Assert(err2, nil)
t.Assert(err3, nil)
@ -591,9 +592,9 @@ func Test_MAC(t *testing.T) {
val1 := "192.168.1.1"
val2 := "44-45-53-54-00-00"
val3 := "01:00:5e:00:00:00"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
t.AssertNE(err1, nil)
t.Assert(err2, nil)
t.Assert(err3, nil)
@ -607,10 +608,10 @@ func Test_URL(t *testing.T) {
val2 := "https://www.baidu.com"
val3 := "http://127.0.0.1"
val4 := "file:///tmp/test.txt"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
t.AssertNE(err1, nil)
t.Assert(err2, nil)
t.Assert(err3, nil)
@ -637,7 +638,7 @@ func Test_Domain(t *testing.T) {
}
var err error
for k, v := range m {
err = gvalid.Check(k, "domain", nil)
err = gvalid.Check(context.TODO(), k, "domain", nil)
if v {
//fmt.Println(k)
t.Assert(err, nil)
@ -651,10 +652,10 @@ func Test_Domain(t *testing.T) {
func Test_Length(t *testing.T) {
rule := "length:6,16"
if m := gvalid.Check("123456", rule, nil); m != nil {
if m := gvalid.Check(context.TODO(), "123456", rule, nil); m != nil {
t.Error(m)
}
if m := gvalid.Check("12345", rule, nil); m == nil {
if m := gvalid.Check(context.TODO(), "12345", rule, nil); m == nil {
t.Error("长度校验失败")
}
}
@ -664,18 +665,18 @@ func Test_MinLength(t *testing.T) {
msgs := map[string]string{
"min-length": "地址长度至少为:min位",
}
if m := gvalid.Check("123456", rule, nil); m != nil {
if m := gvalid.Check(context.TODO(), "123456", rule, nil); m != nil {
t.Error(m)
}
if m := gvalid.Check("12345", rule, nil); m == nil {
if m := gvalid.Check(context.TODO(), "12345", rule, nil); m == nil {
t.Error("长度校验失败")
}
if m := gvalid.Check("12345", rule, msgs); m == nil {
if m := gvalid.Check(context.TODO(), "12345", rule, msgs); m == nil {
t.Error("长度校验失败")
}
rule2 := "min-length:abc"
if m := gvalid.Check("123456", rule2, nil); m == nil {
if m := gvalid.Check(context.TODO(), "123456", rule2, nil); m == nil {
t.Error("长度校验失败")
}
}
@ -685,31 +686,31 @@ func Test_MaxLength(t *testing.T) {
msgs := map[string]string{
"max-length": "地址长度至大为:max位",
}
if m := gvalid.Check("12345", rule, nil); m != nil {
if m := gvalid.Check(context.TODO(), "12345", rule, nil); m != nil {
t.Error(m)
}
if m := gvalid.Check("1234567", rule, nil); m == nil {
if m := gvalid.Check(context.TODO(), "1234567", rule, nil); m == nil {
t.Error("长度校验失败")
}
if m := gvalid.Check("1234567", rule, msgs); m == nil {
if m := gvalid.Check(context.TODO(), "1234567", rule, msgs); m == nil {
t.Error("长度校验失败")
}
rule2 := "max-length:abc"
if m := gvalid.Check("123456", rule2, nil); m == nil {
if m := gvalid.Check(context.TODO(), "123456", rule2, nil); m == nil {
t.Error("长度校验失败")
}
}
func Test_Between(t *testing.T) {
rule := "between:6.01, 10.01"
if m := gvalid.Check(10, rule, nil); m != nil {
if m := gvalid.Check(context.TODO(), 10, rule, nil); m != nil {
t.Error(m)
}
if m := gvalid.Check(10.02, rule, nil); m == nil {
if m := gvalid.Check(context.TODO(), 10.02, rule, nil); m == nil {
t.Error("大小范围校验失败")
}
if m := gvalid.Check("a", rule, nil); m == nil {
if m := gvalid.Check(context.TODO(), "a", rule, nil); m == nil {
t.Error("大小范围校验失败")
}
}
@ -722,11 +723,11 @@ func Test_Min(t *testing.T) {
val3 := "100"
val4 := "1000"
val5 := "a"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err5 := gvalid.Check(val5, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
err5 := gvalid.Check(context.TODO(), val5, rule, nil)
t.AssertNE(err1, nil)
t.AssertNE(err2, nil)
t.Assert(err3, nil)
@ -734,7 +735,7 @@ func Test_Min(t *testing.T) {
t.AssertNE(err5, nil)
rule2 := "min:a"
err6 := gvalid.Check(val1, rule2, nil)
err6 := gvalid.Check(context.TODO(), val1, rule2, nil)
t.AssertNE(err6, nil)
})
}
@ -747,11 +748,11 @@ func Test_Max(t *testing.T) {
val3 := "100"
val4 := "1000"
val5 := "a"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err5 := gvalid.Check(val5, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
err5 := gvalid.Check(context.TODO(), val5, rule, nil)
t.Assert(err1, nil)
t.Assert(err2, nil)
t.Assert(err3, nil)
@ -759,7 +760,7 @@ func Test_Max(t *testing.T) {
t.AssertNE(err5, nil)
rule2 := "max:a"
err6 := gvalid.Check(val1, rule2, nil)
err6 := gvalid.Check(context.TODO(), val1, rule2, nil)
t.AssertNE(err6, nil)
})
}
@ -773,12 +774,12 @@ func Test_Json(t *testing.T) {
val4 := "[]"
val5 := "[1,2,3,4]"
val6 := `{"list":[1,2,3,4]}`
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err5 := gvalid.Check(val5, rule, nil)
err6 := gvalid.Check(val6, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
err5 := gvalid.Check(context.TODO(), val5, rule, nil)
err6 := gvalid.Check(context.TODO(), val6, rule, nil)
t.AssertNE(err1, nil)
t.AssertNE(err2, nil)
t.Assert(err3, nil)
@ -797,12 +798,12 @@ func Test_Integer(t *testing.T) {
val4 := "1"
val5 := "100"
val6 := `999999999`
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err5 := gvalid.Check(val5, rule, nil)
err6 := gvalid.Check(val6, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
err5 := gvalid.Check(context.TODO(), val5, rule, nil)
err6 := gvalid.Check(context.TODO(), val6, rule, nil)
t.AssertNE(err1, nil)
t.AssertNE(err2, nil)
t.Assert(err3, nil)
@ -821,12 +822,12 @@ func Test_Float(t *testing.T) {
val4 := "1.0"
val5 := "1.1"
val6 := `0.1`
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err5 := gvalid.Check(val5, rule, nil)
err6 := gvalid.Check(val6, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
err5 := gvalid.Check(context.TODO(), val5, rule, nil)
err6 := gvalid.Check(context.TODO(), val6, rule, nil)
t.AssertNE(err1, nil)
t.AssertNE(err2, nil)
t.Assert(err3, nil)
@ -845,12 +846,12 @@ func Test_Boolean(t *testing.T) {
val4 := "1"
val5 := "true"
val6 := `off`
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err5 := gvalid.Check(val5, rule, nil)
err6 := gvalid.Check(val6, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
err5 := gvalid.Check(context.TODO(), val5, rule, nil)
err6 := gvalid.Check(context.TODO(), val6, rule, nil)
t.AssertNE(err1, nil)
t.AssertNE(err2, nil)
t.Assert(err3, nil)
@ -874,9 +875,9 @@ func Test_Same(t *testing.T) {
"id": 100,
"name": "john",
}
err1 := gvalid.Check(val1, rule, nil, params1)
err2 := gvalid.Check(val1, rule, nil, params2)
err3 := gvalid.Check(val1, rule, nil, params3)
err1 := gvalid.Check(context.TODO(), val1, rule, nil, params1)
err2 := gvalid.Check(context.TODO(), val1, rule, nil, params2)
err3 := gvalid.Check(context.TODO(), val1, rule, nil, params3)
t.AssertNE(err1, nil)
t.Assert(err2, nil)
t.Assert(err3, nil)
@ -897,9 +898,9 @@ func Test_Different(t *testing.T) {
"id": 100,
"name": "john",
}
err1 := gvalid.Check(val1, rule, nil, params1)
err2 := gvalid.Check(val1, rule, nil, params2)
err3 := gvalid.Check(val1, rule, nil, params3)
err1 := gvalid.Check(context.TODO(), val1, rule, nil, params1)
err2 := gvalid.Check(context.TODO(), val1, rule, nil, params2)
err3 := gvalid.Check(context.TODO(), val1, rule, nil, params3)
t.Assert(err1, nil)
t.AssertNE(err2, nil)
t.AssertNE(err3, nil)
@ -913,10 +914,10 @@ func Test_In(t *testing.T) {
val2 := "1"
val3 := "100"
val4 := "200"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
t.AssertNE(err1, nil)
t.AssertNE(err2, nil)
t.Assert(err3, nil)
@ -931,10 +932,10 @@ func Test_NotIn(t *testing.T) {
val2 := "1"
val3 := "100"
val4 := "200"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
t.Assert(err1, nil)
t.Assert(err2, nil)
t.AssertNE(err3, nil)
@ -946,10 +947,10 @@ func Test_NotIn(t *testing.T) {
val2 := "1"
val3 := "100"
val4 := "200"
err1 := gvalid.Check(val1, rule, nil)
err2 := gvalid.Check(val2, rule, nil)
err3 := gvalid.Check(val3, rule, nil)
err4 := gvalid.Check(val4, rule, nil)
err1 := gvalid.Check(context.TODO(), val1, rule, nil)
err2 := gvalid.Check(context.TODO(), val2, rule, nil)
err3 := gvalid.Check(context.TODO(), val3, rule, nil)
err4 := gvalid.Check(context.TODO(), val4, rule, nil)
t.Assert(err1, nil)
t.Assert(err2, nil)
t.AssertNE(err3, nil)
@ -959,10 +960,10 @@ func Test_NotIn(t *testing.T) {
func Test_Regex1(t *testing.T) {
rule := `regex:\d{6}|\D{6}|length:6,16`
if m := gvalid.Check("123456", rule, nil); m != nil {
if m := gvalid.Check(context.TODO(), "123456", rule, nil); m != nil {
t.Error(m)
}
if m := gvalid.Check("abcde6", rule, nil); m == nil {
if m := gvalid.Check(context.TODO(), "abcde6", rule, nil); m == nil {
t.Error("校验失败")
}
}
@ -973,9 +974,9 @@ func Test_Regex2(t *testing.T) {
str1 := ""
str2 := "data"
str3 := "data:image/jpeg;base64,/9jrbattq22r"
err1 := gvalid.Check(str1, rule, nil)
err2 := gvalid.Check(str2, rule, nil)
err3 := gvalid.Check(str3, rule, nil)
err1 := gvalid.Check(context.TODO(), str1, rule, nil)
err2 := gvalid.Check(context.TODO(), str2, rule, nil)
err3 := gvalid.Check(context.TODO(), str3, rule, nil)
t.AssertNE(err1, nil)
t.AssertNE(err2, nil)
t.Assert(err3, nil)
@ -992,7 +993,7 @@ func Test_InternalError_String(t *testing.T) {
Name string `v:"hh"`
}
aa := a{Name: "2"}
err := gvalid.CheckStruct(&aa, nil)
err := gvalid.CheckStruct(context.TODO(), &aa, nil)
t.Assert(err.String(), "invalid_rules: hh")
t.Assert(err.Strings(), g.Slice{"invalid_rules: hh"})

21
util/gvalid/gvalid_z_unit_checkmap_test.go
View File

@ -7,6 +7,7 @@
package gvalid_test
import (
"context"
"github.com/gogf/gf/errors/gerror"
"testing"
@ -24,7 +25,7 @@ func Test_CheckMap1(t *testing.T) {
"id": "required|between:1,100",
"name": "required|length:6,16",
}
if m := gvalid.CheckMap(data, rules); m == nil {
if m := gvalid.CheckMap(context.TODO(), data, rules); m == nil {
t.Error("CheckMap校验失败")
} else {
t.Assert(len(m.Maps()), 2)
@ -37,7 +38,7 @@ func Test_CheckMap1(t *testing.T) {
func Test_CheckMap2(t *testing.T) {
var params interface{}
gtest.C(t, func(t *gtest.T) {
if err := gvalid.CheckMap(params, nil, nil); err == nil {
if err := gvalid.CheckMap(context.TODO(), params, nil, nil); err == nil {
t.Assert(err, nil)
}
})
@ -57,7 +58,7 @@ func Test_CheckMap2(t *testing.T) {
"length": "名称长度为:min到:max个字符",
},
}
if m := gvalid.CheckMap(kvmap, rules, msgs); m == nil {
if m := gvalid.CheckMap(context.TODO(), kvmap, rules, msgs); m == nil {
t.Error("CheckMap校验失败")
}
@ -76,7 +77,7 @@ func Test_CheckMap2(t *testing.T) {
"length": "名称长度为:min到:max个字符",
},
}
if m := gvalid.CheckMap(kvmap, rules, msgs); m != nil {
if m := gvalid.CheckMap(context.TODO(), kvmap, rules, msgs); m != nil {
t.Error(m)
}
@ -95,7 +96,7 @@ func Test_CheckMap2(t *testing.T) {
"length": "名称长度为:min到:max个字符",
},
}
if m := gvalid.CheckMap(kvmap, rules, msgs); m != nil {
if m := gvalid.CheckMap(context.TODO(), kvmap, rules, msgs); m != nil {
t.Error(m)
}
@ -114,7 +115,7 @@ func Test_CheckMap2(t *testing.T) {
"length": "名称长度为:min到:max个字符",
},
}
if m := gvalid.CheckMap(kvmap, rules2, msgs); m != nil {
if m := gvalid.CheckMap(context.TODO(), kvmap, rules2, msgs); m != nil {
t.Error(m)
}
@ -133,7 +134,7 @@ func Test_CheckMap2(t *testing.T) {
"length": "名称长度为:min到:max个字符",
},
}
if m := gvalid.CheckMap(kvmap, rules2, msgs); m != nil {
if m := gvalid.CheckMap(context.TODO(), kvmap, rules2, msgs); m != nil {
t.Error(m)
}
@ -152,7 +153,7 @@ func Test_CheckMap2(t *testing.T) {
"length": "名称长度为:min到:max个字符",
},
}
if m := gvalid.CheckMap(kvmap, rules2, msgs); m != nil {
if m := gvalid.CheckMap(context.TODO(), kvmap, rules2, msgs); m != nil {
t.Error(m)
}
}
@ -166,7 +167,7 @@ func Test_CheckMapWithNilAndNotRequiredField(t *testing.T) {
"id": "required",
"name": "length:4,16",
}
if m := gvalid.CheckMap(data, rules); m != nil {
if m := gvalid.CheckMap(context.TODO(), data, rules); m != nil {
t.Error(m)
}
}
@ -183,7 +184,7 @@ func Test_Sequence(t *testing.T) {
"password@required|length:6,16|same:password2#密码不能为空|密码长度应当在:min到:max之间|两次密码输入不相等",
"password2@required|length:6,16#",
}
err := gvalid.CheckMap(params, rules)
err := gvalid.CheckMap(context.TODO(), params, rules)
t.AssertNE(err, nil)
t.Assert(len(err.Map()), 2)
t.Assert(err.Map()["required"], "账号不能为空")

47
util/gvalid/gvalid_z_unit_checkstruct_test.go
View File

@ -7,6 +7,7 @@
package gvalid_test
import (
"context"
"github.com/gogf/gf/container/gvar"
"github.com/gogf/gf/os/gtime"
"testing"
@ -35,7 +36,7 @@ func Test_CheckStruct(t *testing.T) {
"Age": "年龄为18到30周岁",
}
obj := &Object{"john", 16}
err := gvalid.CheckStruct(obj, rules, msgs)
err := gvalid.CheckStruct(context.TODO(), obj, rules, msgs)
t.Assert(err, nil)
})
@ -56,7 +57,7 @@ func Test_CheckStruct(t *testing.T) {
"Age": "年龄为18到30周岁",
}
obj := &Object{"john", 16}
err := gvalid.CheckStruct(obj, rules, msgs)
err := gvalid.CheckStruct(context.TODO(), obj, rules, msgs)
t.AssertNE(err, nil)
t.Assert(len(err.Maps()), 2)
t.Assert(err.Maps()["Name"]["required"], "")
@ -81,7 +82,7 @@ func Test_CheckStruct(t *testing.T) {
"Age": "年龄为18到30周岁",
}
obj := &Object{"john", 16}
err := gvalid.CheckStruct(obj, rules, msgs)
err := gvalid.CheckStruct(context.TODO(), obj, rules, msgs)
t.AssertNE(err, nil)
t.Assert(len(err.Maps()), 2)
t.Assert(err.Maps()["Name"]["required"], "")
@ -106,7 +107,7 @@ func Test_CheckStruct(t *testing.T) {
"Age": "年龄为18到30周岁",
}
obj := &Object{"john", 16}
err := gvalid.CheckStruct(obj, rules, msgs)
err := gvalid.CheckStruct(context.TODO(), obj, rules, msgs)
t.AssertNE(err, nil)
t.Assert(len(err.Maps()), 2)
t.Assert(err.Maps()["Name"]["required"], "")
@ -120,7 +121,7 @@ func Test_CheckStruct(t *testing.T) {
Password string `json:"password" gvalid:"password@required#登录密码不能为空"`
}
var login LoginRequest
err := gvalid.CheckStruct(login, nil)
err := gvalid.CheckStruct(context.TODO(), login, nil)
t.AssertNE(err, nil)
t.Assert(len(err.Maps()), 2)
t.Assert(err.Maps()["username"]["required"], "用户名不能为空")
@ -133,7 +134,7 @@ func Test_CheckStruct(t *testing.T) {
Password string `json:"password" gvalid:"@required#登录密码不能为空"`
}
var login LoginRequest
err := gvalid.CheckStruct(login, nil)
err := gvalid.CheckStruct(context.TODO(), login, nil)
t.Assert(err, nil)
})
@ -143,7 +144,7 @@ func Test_CheckStruct(t *testing.T) {
Password string `json:"password" gvalid:"password@required#登录密码不能为空"`
}
var login LoginRequest
err := gvalid.CheckStruct(login, nil)
err := gvalid.CheckStruct(context.TODO(), login, nil)
t.AssertNE(err, nil)
t.Assert(err.Maps()["password"]["required"], "登录密码不能为空")
})
@ -161,7 +162,7 @@ func Test_CheckStruct(t *testing.T) {
Username: "john",
Password: "123456",
}
err := gvalid.CheckStruct(user, nil)
err := gvalid.CheckStruct(context.TODO(), user, nil)
t.AssertNE(err, nil)
t.Assert(len(err.Maps()), 1)
t.Assert(err.Maps()["uid"]["min"], "ID不能为空")
@ -184,7 +185,7 @@ func Test_CheckStruct(t *testing.T) {
"username@required#用户名不能为空",
}
err := gvalid.CheckStruct(user, rules)
err := gvalid.CheckStruct(context.TODO(), user, rules)
t.AssertNE(err, nil)
t.Assert(len(err.Maps()), 1)
t.Assert(err.Maps()["uid"]["min"], "ID不能为空")
@ -202,7 +203,7 @@ func Test_CheckStruct(t *testing.T) {
Username: "john",
Password: "123456",
}
err := gvalid.CheckStruct(user, nil)
err := gvalid.CheckStruct(context.TODO(), user, nil)
t.AssertNE(err, nil)
t.Assert(len(err.Maps()), 1)
})
@ -220,7 +221,7 @@ func Test_CheckStruct(t *testing.T) {
Username: "john",
Password: "123456",
}
err := gvalid.CheckStruct(user, nil)
err := gvalid.CheckStruct(context.TODO(), user, nil)
t.AssertNE(err, nil)
t.Assert(len(err.Maps()), 1)
t.Assert(err.Maps()["uid"]["min"], "ID不能为空")
@ -245,7 +246,7 @@ func Test_CheckStruct_With_EmbeddedObject(t *testing.T) {
Pass2: "2",
},
}
err := gvalid.CheckStruct(user, nil)
err := gvalid.CheckStruct(context.TODO(), user, nil)
t.AssertNE(err, nil)
t.Assert(err.Maps()["name"], g.Map{"required": "请输入您的姓名"})
t.Assert(err.Maps()["password1"], g.Map{"same": "您两次输入的密码不一致"})
@ -271,7 +272,7 @@ func Test_CheckStruct_With_StructAttribute(t *testing.T) {
Pass2: "2",
},
}
err := gvalid.CheckStruct(user, nil)
err := gvalid.CheckStruct(context.TODO(), user, nil)
t.AssertNE(err, nil)
t.Assert(err.Maps()["name"], g.Map{"required": "请输入您的姓名"})
t.Assert(err.Maps()["password1"], g.Map{"same": "您两次输入的密码不一致"})
@ -290,7 +291,7 @@ func Test_CheckStruct_Optional(t *testing.T) {
Page: 1,
Size: 10,
}
err := gvalid.CheckStruct(obj, nil)
err := gvalid.CheckStruct(context.TODO(), obj, nil)
t.Assert(err, nil)
})
gtest.C(t, func(t *gtest.T) {
@ -303,7 +304,7 @@ func Test_CheckStruct_Optional(t *testing.T) {
Page: 1,
Size: 10,
}
err := gvalid.CheckStruct(obj, nil)
err := gvalid.CheckStruct(context.TODO(), obj, nil)
t.Assert(err, nil)
})
gtest.C(t, func(t *gtest.T) {
@ -316,7 +317,7 @@ func Test_CheckStruct_Optional(t *testing.T) {
Page: 1,
Size: 10,
}
err := gvalid.CheckStruct(obj, nil)
err := gvalid.CheckStruct(context.TODO(), obj, nil)
t.Assert(err.String(), "project id must between 1, 10000")
})
}
@ -332,7 +333,7 @@ func Test_CheckStruct_NoTag(t *testing.T) {
Page: 1,
Size: 10,
}
err := gvalid.CheckStruct(obj, nil)
err := gvalid.CheckStruct(context.TODO(), obj, nil)
t.Assert(err, nil)
})
}
@ -349,7 +350,7 @@ func Test_CheckStruct_InvalidRule(t *testing.T) {
Age: 18,
Phone: "123",
}
err := gvalid.CheckStruct(obj, nil)
err := gvalid.CheckStruct(context.TODO(), obj, nil)
t.AssertNE(err, nil)
})
}
@ -364,7 +365,7 @@ func TestValidator_CheckStructWithParamMap(t *testing.T) {
Uid: 1,
Nickname: "john",
}
t.Assert(gvalid.CheckStructWithParamMap(data, g.Map{"uid": 1, "nickname": "john"}, nil), nil)
t.Assert(gvalid.CheckStructWithParamMap(context.TODO(), data, g.Map{"uid": 1, "nickname": "john"}, nil), nil)
})
gtest.C(t, func(t *gtest.T) {
type UserApiSearch struct {
@ -372,7 +373,7 @@ func TestValidator_CheckStructWithParamMap(t *testing.T) {
Nickname string `v:"required-with:uid"`
}
data := UserApiSearch{}
t.AssertNE(gvalid.CheckStructWithParamMap(data, g.Map{}, nil), nil)
t.AssertNE(gvalid.CheckStructWithParamMap(context.TODO(), data, g.Map{}, nil), nil)
})
gtest.C(t, func(t *gtest.T) {
type UserApiSearch struct {
@ -382,7 +383,7 @@ func TestValidator_CheckStructWithParamMap(t *testing.T) {
data := UserApiSearch{
Uid: 1,
}
t.AssertNE(gvalid.CheckStructWithParamMap(data, g.Map{}, nil), nil)
t.AssertNE(gvalid.CheckStructWithParamMap(context.TODO(), data, g.Map{}, nil), nil)
})
gtest.C(t, func(t *gtest.T) {
@ -396,7 +397,7 @@ func TestValidator_CheckStructWithParamMap(t *testing.T) {
StartTime: nil,
EndTime: nil,
}
t.Assert(gvalid.CheckStructWithParamMap(data, g.Map{}, nil), nil)
t.Assert(gvalid.CheckStructWithParamMap(context.TODO(), data, g.Map{}, nil), nil)
})
gtest.C(t, func(t *gtest.T) {
type UserApiSearch struct {
@ -409,6 +410,6 @@ func TestValidator_CheckStructWithParamMap(t *testing.T) {
StartTime: gtime.Now(),
EndTime: nil,
}
t.AssertNE(gvalid.CheckStructWithParamMap(data, g.Map{"start_time": gtime.Now()}, nil), nil)
t.AssertNE(gvalid.CheckStructWithParamMap(context.TODO(), data, g.Map{"start_time": gtime.Now()}, nil), nil)
})
}

27
util/gvalid/gvalid_z_unit_custom_rule_test.go
View File

@ -7,6 +7,7 @@
package gvalid_test
import (
"context"
"errors"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/util/gconv"
@ -30,9 +31,9 @@ func Test_CustomRule1(t *testing.T) {
})
gtest.Assert(err, nil)
gtest.C(t, func(t *gtest.T) {
err := gvalid.Check("123456", rule, "custom message")
err := gvalid.Check(context.TODO(), "123456", rule, "custom message")
t.Assert(err.String(), "custom message")
err = gvalid.Check("123456", rule, "custom message", g.Map{"data": "123456"})
err = gvalid.Check(context.TODO(), "123456", rule, "custom message", g.Map{"data": "123456"})
t.Assert(err, nil)
})
// Error with struct validation.
@ -45,7 +46,7 @@ func Test_CustomRule1(t *testing.T) {
Value: "123",
Data: "123456",
}
err := gvalid.CheckStruct(st, nil)
err := gvalid.CheckStruct(context.TODO(), st, nil)
t.Assert(err.String(), "自定义错误")
})
// No error with struct validation.
@ -58,7 +59,7 @@ func Test_CustomRule1(t *testing.T) {
Value: "123456",
Data: "123456",
}
err := gvalid.CheckStruct(st, nil)
err := gvalid.CheckStruct(context.TODO(), st, nil)
t.Assert(err, nil)
})
}
@ -76,8 +77,8 @@ func Test_CustomRule2(t *testing.T) {
// Check.
gtest.C(t, func(t *gtest.T) {
errStr := "data map should not be empty"
t.Assert(gvalid.Check(g.Map{}, rule, errStr).String(), errStr)
t.Assert(gvalid.Check(g.Map{"k": "v"}, rule, errStr).String(), nil)
t.Assert(gvalid.Check(context.TODO(), g.Map{}, rule, errStr).String(), errStr)
t.Assert(gvalid.Check(context.TODO(), g.Map{"k": "v"}, rule, errStr).String(), nil)
})
// Error with struct validation.
gtest.C(t, func(t *gtest.T) {
@ -89,7 +90,7 @@ func Test_CustomRule2(t *testing.T) {
Value: map[string]string{},
Data: "123456",
}
err := gvalid.CheckStruct(st, nil)
err := gvalid.CheckStruct(context.TODO(), st, nil)
t.Assert(err.String(), "自定义错误")
})
// No error with struct validation.
@ -102,7 +103,7 @@ func Test_CustomRule2(t *testing.T) {
Value: map[string]string{"k": "v"},
Data: "123456",
}
err := gvalid.CheckStruct(st, nil)
err := gvalid.CheckStruct(context.TODO(), st, nil)
t.Assert(err, nil)
})
}
@ -120,9 +121,9 @@ func Test_CustomRule_AllowEmpty(t *testing.T) {
// Check.
gtest.C(t, func(t *gtest.T) {
errStr := "error"
t.Assert(gvalid.Check("", rule, errStr).String(), "")
t.Assert(gvalid.Check("gf", rule, errStr).String(), "")
t.Assert(gvalid.Check("gf2", rule, errStr).String(), errStr)
t.Assert(gvalid.Check(context.TODO(), "", rule, errStr).String(), "")
t.Assert(gvalid.Check(context.TODO(), "gf", rule, errStr).String(), "")
t.Assert(gvalid.Check(context.TODO(), "gf2", rule, errStr).String(), errStr)
})
// Error with struct validation.
gtest.C(t, func(t *gtest.T) {
@ -134,7 +135,7 @@ func Test_CustomRule_AllowEmpty(t *testing.T) {
Value: "",
Data: "123456",
}
err := gvalid.CheckStruct(st, nil)
err := gvalid.CheckStruct(context.TODO(), st, nil)
t.Assert(err.String(), "")
})
// No error with struct validation.
@ -147,7 +148,7 @@ func Test_CustomRule_AllowEmpty(t *testing.T) {
Value: "john",
Data: "123456",
}
err := gvalid.CheckStruct(st, nil)
err := gvalid.CheckStruct(context.TODO(), st, nil)
t.Assert(err.String(), "自定义错误")
})
}

9
util/gvalid/gvalid_z_unit_customerror_test.go
View File

@ -7,6 +7,7 @@
package gvalid_test
import (
"context"
"strings"
"testing"
@ -19,7 +20,7 @@ func Test_Map(t *testing.T) {
var (
rule = "ipv4"
val = "0.0.0"
err = gvalid.Check(val, rule, nil)
err = gvalid.Check(context.TODO(), val, rule, nil)
msg = map[string]string{
"ipv4": "The value must be a valid IPv4 address",
}
@ -33,7 +34,7 @@ func Test_FirstString(t *testing.T) {
var (
rule = "ipv4"
val = "0.0.0"
err = gvalid.Check(val, rule, nil)
err = gvalid.Check(context.TODO(), val, rule, nil)
n = err.FirstString()
)
t.Assert(n, "The value must be a valid IPv4 address")
@ -46,7 +47,7 @@ func Test_CustomError1(t *testing.T) {
"integer": "请输入一个整数",
"length": "参数长度不对啊老铁",
}
e := gvalid.Check("6.66", rule, msgs)
e := gvalid.Check(context.TODO(), "6.66", rule, msgs)
if e == nil || len(e.Map()) != 2 {
t.Error("规则校验失败")
} else {
@ -66,7 +67,7 @@ func Test_CustomError1(t *testing.T) {
func Test_CustomError2(t *testing.T) {
rule := "integer|length:6,16"
msgs := "请输入一个整数|参数长度不对啊老铁"
e := gvalid.Check("6.66", rule, msgs)
e := gvalid.Check(context.TODO(), "6.66", rule, msgs)
if e == nil || len(e.Map()) != 2 {
t.Error("规则校验失败")
} else {