zeromicro
/
go-zero
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chore: add more tests (#3282)

Browse Source
master
Kevin Wan 2 years ago committed by GitHub
parent d76a39ac26
commit fa33329a44
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 635 additions and 196 deletions
Show Stats Download Patch File Download Diff File

9
core/mapping/unmarshaler.go
Unescape Escape View File

@ -148,14 +148,17 @@ func (u *Unmarshaler) fillSlice(fieldType reflect.Type, value reflect.Value, map
return errValueNotSettable
}
baseType := fieldType.Elem()
dereffedBaseType := Deref(baseType)
dereffedBaseKind := dereffedBaseType.Kind()
refValue := reflect.ValueOf(mapValue)
if refValue.Kind() != reflect.Slice {
return errTypeMismatch
}
if refValue.IsNil() {
return nil
}
baseType := fieldType.Elem()
dereffedBaseType := Deref(baseType)
dereffedBaseKind := dereffedBaseType.Kind()
conv := reflect.MakeSlice(reflect.SliceOf(baseType), refValue.Len(), refValue.Cap())
if refValue.Len() == 0 {
value.Set(conv)

444
core/mapping/unmarshaler_test.go
Unescape Escape View File

@ -306,6 +306,7 @@ func TestUnmarshalIntPtr(t *testing.T) {
}
func TestUnmarshalIntSliceOfPtr(t *testing.T) {
t.Run("int slice", func(t *testing.T) {
type inner struct {
Ints []*int `key:"ints"`
Intps []**int `key:"intps"`
@ -330,6 +331,36 @@ func TestUnmarshalIntSliceOfPtr(t *testing.T) {
}
assert.EqualValues(t, []int{1, 2, 3, 4}, intps)
}
})
t.Run("int slice with error", func(t *testing.T) {
type inner struct {
Ints []*int `key:"ints"`
Intps []**int `key:"intps"`
}
m := map[string]any{
"ints": []any{1, 2, "a"},
"intps": []int{1, 2, 3, 4},
}
var in inner
assert.Error(t, UnmarshalKey(m, &in))
})
t.Run("int slice with nil", func(t *testing.T) {
type inner struct {
Ints []int `key:"ints"`
}
m := map[string]any{
"ints": []any{nil},
}
var in inner
if assert.NoError(t, UnmarshalKey(m, &in)) {
assert.Empty(t, in.Ints)
}
})
}
func TestUnmarshalIntWithDefault(t *testing.T) {
@ -373,6 +404,42 @@ func TestUnmarshalIntWithString(t *testing.T) {
}
})
t.Run("int wrong range", func(t *testing.T) {
type inner struct {
Int int64 `key:"int,string,range=[2:3]"`
Intp *int64 `key:"intp,range=[2:3]"`
Intpp **int64 `key:"intpp,range=[2:3]"`
}
m := map[string]any{
"int": json.Number("1"),
"intp": json.Number("2"),
"intpp": json.Number("3"),
}
var in inner
assert.ErrorIs(t, UnmarshalKey(m, &in), errNumberRange)
})
t.Run("int with wrong type", func(t *testing.T) {
type (
myString string
inner struct {
Int int64 `key:"int,string"`
Intp *int64 `key:"intp,string"`
Intpp **int64 `key:"intpp,string"`
}
)
m := map[string]any{
"int": myString("1"),
"intp": myString("2"),
"intpp": myString("3"),
}
var in inner
assert.Error(t, UnmarshalKey(m, &in))
})
t.Run("int with ptr", func(t *testing.T) {
type inner struct {
Int *int64 `key:"int"`
@ -387,6 +454,54 @@ func TestUnmarshalIntWithString(t *testing.T) {
}
})
t.Run("int with invalid value", func(t *testing.T) {
type inner struct {
Int int64 `key:"int"`
}
m := map[string]any{
"int": json.Number("a"),
}
var in inner
assert.Error(t, UnmarshalKey(m, &in))
})
t.Run("uint with invalid value", func(t *testing.T) {
type inner struct {
Int uint64 `key:"int"`
}
m := map[string]any{
"int": json.Number("a"),
}
var in inner
assert.Error(t, UnmarshalKey(m, &in))
})
t.Run("float with invalid value", func(t *testing.T) {
type inner struct {
Value float64 `key:"float"`
}
m := map[string]any{
"float": json.Number("a"),
}
var in inner
assert.Error(t, UnmarshalKey(m, &in))
})
t.Run("float with invalid value", func(t *testing.T) {
type inner struct {
Value string `key:"value"`
}
m := map[string]any{
"value": json.Number("a"),
}
var in inner
assert.Error(t, UnmarshalKey(m, &in))
})
t.Run("int with ptr of ptr", func(t *testing.T) {
type inner struct {
Int **int64 `key:"int"`
@ -491,6 +606,7 @@ func TestUnmarshalBoolSliceEmpty(t *testing.T) {
}
func TestUnmarshalBoolSliceWithDefault(t *testing.T) {
t.Run("slice with default", func(t *testing.T) {
type inner struct {
Bools []bool `key:"bools,default=[true,false]"`
}
@ -499,6 +615,16 @@ func TestUnmarshalBoolSliceWithDefault(t *testing.T) {
if assert.NoError(t, UnmarshalKey(nil, &in)) {
assert.ElementsMatch(t, []bool{true, false}, in.Bools)
}
})
t.Run("slice with default error", func(t *testing.T) {
type inner struct {
Bools []bool `key:"bools,default=[true,fal]"`
}
var in inner
assert.Error(t, UnmarshalKey(nil, &in))
})
}
func TestUnmarshalIntSliceWithDefault(t *testing.T) {
@ -726,6 +852,7 @@ func TestUnmarshalStringWithMissing(t *testing.T) {
}
func TestUnmarshalStringSliceFromString(t *testing.T) {
t.Run("slice from string", func(t *testing.T) {
var v struct {
Names []string `key:"names"`
}
@ -739,6 +866,31 @@ func TestUnmarshalStringSliceFromString(t *testing.T) {
ast.Equal("first", v.Names[0])
ast.Equal("second", v.Names[1])
}
})
t.Run("slice from string with slice error", func(t *testing.T) {
var v struct {
Names []int `key:"names"`
}
m := map[string]any{
"names": `["first", 1]`,
}
assert.Error(t, UnmarshalKey(m, &v))
})
t.Run("slice from string with error", func(t *testing.T) {
type myString string
var v struct {
Names []string `key:"names"`
}
m := map[string]any{
"names": myString("not a slice"),
}
assert.Error(t, UnmarshalKey(m, &v))
})
}
func TestUnmarshalIntSliceFromString(t *testing.T) {
@ -800,6 +952,7 @@ func (c CustomStringer) String() string {
}
func TestUnmarshalStringMapFromStringer(t *testing.T) {
t.Run("CustomStringer", func(t *testing.T) {
var v struct {
Sort map[string]string `key:"sort"`
}
@ -813,6 +966,18 @@ func TestUnmarshalStringMapFromStringer(t *testing.T) {
ast.Equal("ascend", v.Sort["value"])
ast.Equal("", v.Sort["emptyStr"])
}
})
t.Run("CustomStringer incorrect", func(t *testing.T) {
var v struct {
Sort map[string]string `key:"sort"`
}
m := map[string]any{
"sort": CustomStringer(`"value"`),
}
assert.Error(t, UnmarshalKey(m, &v))
})
}
func TestUnmarshalStringMapFromUnsupportedType(t *testing.T) {
@ -906,6 +1071,7 @@ func TestUnmarshalStringSliceMapFromString(t *testing.T) {
}
func TestUnmarshalStruct(t *testing.T) {
t.Run("struct", func(t *testing.T) {
type address struct {
City string `key:"city"`
ZipCode int `key:"zipcode,string"`
@ -948,6 +1114,40 @@ func TestUnmarshalStruct(t *testing.T) {
ast.Equal(400000, (*in.AddressPP).ZipCode)
ast.Equal("hello", (*in.AddressPP).DefaultString)
}
})
t.Run("struct with error", func(t *testing.T) {
type address struct {
City string `key:"city"`
ZipCode int `key:"zipcode,string"`
DefaultString string `key:"defaultstring,default=hello"`
Optional string `key:",optional"`
}
type inner struct {
Name string `key:"name"`
Address address `key:"address"`
AddressP *address `key:"addressp"`
AddressPP **address `key:"addresspp"`
}
m := map[string]any{
"name": "kevin",
"address": map[string]any{
"city": "shanghai",
"zipcode": "200000",
},
"addressp": map[string]any{
"city": "beijing",
"zipcode": "300000",
},
"addresspp": map[string]any{
"city": "guangzhou",
"zipcode": "a",
},
}
var in inner
assert.Error(t, UnmarshalKey(m, &in))
})
}
func TestUnmarshalStructOptionalDepends(t *testing.T) {
@ -1086,6 +1286,7 @@ func TestUnmarshalStructOptionalDependsNot(t *testing.T) {
}
func TestUnmarshalStructOptionalDependsNotErrorDetails(t *testing.T) {
t.Run("mutal optionals", func(t *testing.T) {
type address struct {
Optional string `key:",optional"`
OptionalDepends string `key:",optional=!Optional"`
@ -1101,6 +1302,28 @@ func TestUnmarshalStructOptionalDependsNotErrorDetails(t *testing.T) {
var in inner
assert.Error(t, UnmarshalKey(m, &in))
})
t.Run("with default", func(t *testing.T) {
type address struct {
Optional string `key:",optional"`
OptionalDepends string `key:",default=value,optional"`
}
type inner struct {
Name string `key:"name"`
Address address `key:"address"`
}
m := map[string]any{
"name": "kevin",
}
var in inner
if assert.NoError(t, UnmarshalKey(m, &in)) {
assert.Equal(t, "kevin", in.Name)
assert.Equal(t, "value", in.Address.OptionalDepends)
}
})
}
func TestUnmarshalStructOptionalDependsNotNested(t *testing.T) {
@ -1440,7 +1663,8 @@ func TestUnmarshalMapOfInt(t *testing.T) {
}
}
func TestUnmarshalMapOfStructError(t *testing.T) {
func TestUnmarshalMapOfStruct(t *testing.T) {
t.Run("map of struct with error", func(t *testing.T) {
m := map[string]any{
"Ids": map[string]any{"first": "second"},
}
@ -1450,6 +1674,37 @@ func TestUnmarshalMapOfStructError(t *testing.T) {
}
}
assert.Error(t, UnmarshalKey(m, &v))
})
t.Run("map of struct", func(t *testing.T) {
m := map[string]any{
"Ids": map[string]any{
"foo": map[string]any{"Name": "foo"},
},
}
var v struct {
Ids map[string]struct {
Name string
}
}
if assert.NoError(t, UnmarshalKey(m, &v)) {
assert.Equal(t, "foo", v.Ids["foo"].Name)
}
})
t.Run("map of struct error", func(t *testing.T) {
m := map[string]any{
"Ids": map[string]any{
"foo": map[string]any{"name": "foo"},
},
}
var v struct {
Ids map[string]struct {
Name string
}
}
assert.Error(t, UnmarshalKey(m, &v))
})
}
func TestUnmarshalSlice(t *testing.T) {
@ -1492,6 +1747,7 @@ func TestUnmarshalSlice(t *testing.T) {
}
func TestUnmarshalSliceOfStruct(t *testing.T) {
t.Run("slice of struct", func(t *testing.T) {
m := map[string]any{
"Ids": []map[string]any{
{
@ -1512,6 +1768,25 @@ func TestUnmarshalSliceOfStruct(t *testing.T) {
ast.Equal(1, v.Ids[0].First)
ast.Equal(2, v.Ids[0].Second)
}
})
t.Run("slice of struct", func(t *testing.T) {
m := map[string]any{
"Ids": []map[string]any{
{
"First": "a",
"Second": 2,
},
},
}
var v struct {
Ids []struct {
First int
Second int
}
}
assert.Error(t, UnmarshalKey(m, &v))
})
}
func TestUnmarshalWithStringOptionsCorrect(t *testing.T) {
@ -3122,6 +3397,7 @@ func TestUnmarshalRangeError(t *testing.T) {
}
func TestUnmarshalNestedMap(t *testing.T) {
t.Run("nested map", func(t *testing.T) {
var c struct {
Anything map[string]map[string]string `json:"anything"`
}
@ -3137,6 +3413,41 @@ func TestUnmarshalNestedMap(t *testing.T) {
if assert.NoError(t, NewUnmarshaler("json").Unmarshal(m, &c)) {
assert.Equal(t, "1", c.Anything["inner"]["id"])
}
})
t.Run("nested map with slice element", func(t *testing.T) {
var c struct {
Anything map[string][]string `json:"anything"`
}
m := map[string]any{
"anything": map[string][]any{
"inner": {
"id",
"name",
},
},
}
if assert.NoError(t, NewUnmarshaler("json").Unmarshal(m, &c)) {
assert.Equal(t, []string{"id", "name"}, c.Anything["inner"])
}
})
t.Run("nested map with slice element error", func(t *testing.T) {
var c struct {
Anything map[string][]string `json:"anything"`
}
m := map[string]any{
"anything": map[string][]any{
"inner": {
"id",
1,
},
},
}
assert.Error(t, NewUnmarshaler("json").Unmarshal(m, &c))
})
}
func TestUnmarshalNestedMapMismatch(t *testing.T) {
@ -3810,6 +4121,7 @@ func TestUnmarshal_EnvWithOptionsWrongValueString(t *testing.T) {
}
func TestUnmarshalJsonReaderMultiArray(t *testing.T) {
t.Run("reader multi array", func(t *testing.T) {
var res struct {
A string `json:"a"`
B [][]string `json:"b"`
@ -3819,6 +4131,17 @@ func TestUnmarshalJsonReaderMultiArray(t *testing.T) {
if assert.NoError(t, UnmarshalJsonReader(reader, &res)) {
assert.Equal(t, 2, len(res.B))
}
})
t.Run("reader multi array with error", func(t *testing.T) {
var res struct {
A string `json:"a"`
B [][]string `json:"b"`
}
payload := `{"a": "133", "b": ["eeee"]}`
reader := strings.NewReader(payload)
assert.Error(t, UnmarshalJsonReader(reader, &res))
})
}
func TestUnmarshalJsonReaderPtrMultiArrayString(t *testing.T) {
@ -4059,12 +4382,24 @@ func TestUnmarshalJsonReaderWithTypeMismatchBool(t *testing.T) {
assert.Equal(t, errTypeMismatch, UnmarshalJsonReader(strings.NewReader(body), &req))
}
func TestUnmarshalJsonReaderWithTypeMismatchString(t *testing.T) {
func TestUnmarshalJsonReaderWithTypeString(t *testing.T) {
t.Run("string type", func(t *testing.T) {
var req struct {
Params map[string]string `json:"params"`
}
body := `{"params":{"a":"b"}}`
if assert.NoError(t, UnmarshalJsonReader(strings.NewReader(body), &req)) {
assert.Equal(t, "b", req.Params["a"])
}
})
t.Run("string type mismatch", func(t *testing.T) {
var req struct {
Params map[string]string `json:"params"`
}
body := `{"params":{"a":{"a":123}}}`
assert.Equal(t, errTypeMismatch, UnmarshalJsonReader(strings.NewReader(body), &req))
})
}
func TestUnmarshalJsonReaderWithMismatchType(t *testing.T) {
@ -4077,7 +4412,41 @@ func TestUnmarshalJsonReaderWithMismatchType(t *testing.T) {
assert.Equal(t, errTypeMismatch, UnmarshalJsonReader(strings.NewReader(body), &req))
}
func TestUnmarshalJsonReaderWithMismatchTypeBool(t *testing.T) {
func TestUnmarshalJsonReaderWithTypeBool(t *testing.T) {
t.Run("bool type", func(t *testing.T) {
type Req struct {
Params map[string]bool `json:"params"`
}
tests := []struct {
name string
input string
expect bool
}{
{
name: "int",
input: `{"params":{"a":1}}`,
expect: true,
},
{
name: "int",
input: `{"params":{"a":0}}`,
expect: false,
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
var req Req
if assert.NoError(t, UnmarshalJsonReader(strings.NewReader(test.input), &req)) {
assert.Equal(t, test.expect, req.Params["a"])
}
})
}
})
t.Run("bool type mismatch", func(t *testing.T) {
type Req struct {
Params map[string]bool `json:"params"`
}
@ -4103,9 +4472,26 @@ func TestUnmarshalJsonReaderWithMismatchTypeBool(t *testing.T) {
assert.Equal(t, errTypeMismatch, UnmarshalJsonReader(strings.NewReader(test.input), &req))
})
}
})
}
func TestUnmarshalJsonReaderWithTypeBoolMap(t *testing.T) {
t.Run("bool map", func(t *testing.T) {
var req struct {
Params map[string]bool `json:"params"`
}
if assert.NoError(t, UnmarshalJsonMap(map[string]any{
"params": map[string]any{
"a": true,
},
}, &req)) {
assert.Equal(t, map[string]bool{
"a": true,
}, req.Params)
}
})
func TestUnmarshalJsonReaderWithMismatchTypeBoolMap(t *testing.T) {
t.Run("bool map with error", func(t *testing.T) {
var req struct {
Params map[string]string `json:"params"`
}
@ -4114,6 +4500,7 @@ func TestUnmarshalJsonReaderWithMismatchTypeBoolMap(t *testing.T) {
"a": true,
},
}, &req))
})
}
func TestUnmarshalJsonBytesSliceOfMaps(t *testing.T) {
@ -4446,6 +4833,55 @@ func Test_UnmarshalMap(t *testing.T) {
var customer Customer
assert.ErrorIs(t, UnmarshalKey(input, &customer), errTypeMismatch)
})
t.Run("map from string", func(t *testing.T) {
type Customer struct {
Names map[string]string `key:"names,string"`
}
input := map[string]any{
"names": `{"name": "Tom"}`,
}
var customer Customer
assert.NoError(t, UnmarshalKey(input, &customer))
assert.Equal(t, "Tom", customer.Names["name"])
})
t.Run("map from string with error", func(t *testing.T) {
type Customer struct {
Names map[string]any `key:"names,string"`
}
input := map[string]any{
"names": `"name"`,
}
var customer Customer
assert.Error(t, UnmarshalKey(input, &customer))
})
}
// func TestUnmarshalWithFillPrimitives(t *testing.T) {
// t.Run("fill primitives", func(t *testing.T) {
// type St struct {
// A int `key:"a,string,range=[5,10]"`
// }
// var st St
// err := UnmarshalKey(map[string]any{
// "a": "1",
// }, &st)
// assert.ErrorIs(t, err, errNumberRange)
// })
// }
func TestUnmarshaler_Unmarshal(t *testing.T) {
t.Run("not struct", func(t *testing.T) {
var i int
unmarshaler := NewUnmarshaler(jsonTagKey)
err := unmarshaler.UnmarshalValuer(nil, &i)
assert.Error(t, err)
})
}
func TestGetValueWithChainedKeys(t *testing.T) {

Write Preview
Loading…
Cancel
Save