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)

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

@ -306,30 +306,61 @@ func TestUnmarshalIntPtr(t *testing.T) {
}
func TestUnmarshalIntSliceOfPtr(t *testing.T) {
type inner struct {
Ints []*int `key:"ints"`
Intps []**int `key:"intps"`
}
m := map[string]any{
"ints": []int{1, 2, 3},
"intps": []int{1, 2, 3, 4},
}
t.Run("int slice", func(t *testing.T) {
type inner struct {
Ints []*int `key:"ints"`
Intps []**int `key:"intps"`
}
m := map[string]any{
"ints": []int{1, 2, 3},
"intps": []int{1, 2, 3, 4},
}
var in inner
if assert.NoError(t, UnmarshalKey(m, &in)) {
assert.NotEmpty(t, in.Ints)
var ints []int
for _, i := range in.Ints {
ints = append(ints, *i)
var in inner
if assert.NoError(t, UnmarshalKey(m, &in)) {
assert.NotEmpty(t, in.Ints)
var ints []int
for _, i := range in.Ints {
ints = append(ints, *i)
}
assert.EqualValues(t, []int{1, 2, 3}, ints)
var intps []int
for _, i := range in.Intps {
intps = append(intps, **i)
}
assert.EqualValues(t, []int{1, 2, 3, 4}, intps)
}
assert.EqualValues(t, []int{1, 2, 3}, ints)
})
var intps []int
for _, i := range in.Intps {
intps = append(intps, **i)
t.Run("int slice with error", func(t *testing.T) {
type inner struct {
Ints []*int `key:"ints"`
Intps []**int `key:"intps"`
}
assert.EqualValues(t, []int{1, 2, 3, 4}, 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,14 +606,25 @@ func TestUnmarshalBoolSliceEmpty(t *testing.T) {
}
func TestUnmarshalBoolSliceWithDefault(t *testing.T) {
type inner struct {
Bools []bool `key:"bools,default=[true,false]"`
}
t.Run("slice with default", func(t *testing.T) {
type inner struct {
Bools []bool `key:"bools,default=[true,false]"`
}
var in inner
if assert.NoError(t, UnmarshalKey(nil, &in)) {
assert.ElementsMatch(t, []bool{true, false}, in.Bools)
}
var in inner
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,19 +852,45 @@ func TestUnmarshalStringWithMissing(t *testing.T) {
}
func TestUnmarshalStringSliceFromString(t *testing.T) {
var v struct {
Names []string `key:"names"`
}
m := map[string]any{
"names": `["first", "second"]`,
}
t.Run("slice from string", func(t *testing.T) {
var v struct {
Names []string `key:"names"`
}
m := map[string]any{
"names": `["first", "second"]`,
}
ast := assert.New(t)
if ast.NoError(UnmarshalKey(m, &v)) {
ast.Equal(2, len(v.Names))
ast.Equal("first", v.Names[0])
ast.Equal("second", v.Names[1])
}
ast := assert.New(t)
if ast.NoError(UnmarshalKey(m, &v)) {
ast.Equal(2, len(v.Names))
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,19 +952,32 @@ func (c CustomStringer) String() string {
}
func TestUnmarshalStringMapFromStringer(t *testing.T) {
var v struct {
Sort map[string]string `key:"sort"`
}
m := map[string]any{
"sort": CustomStringer(`"value":"ascend","emptyStr":""`),
}
t.Run("CustomStringer", func(t *testing.T) {
var v struct {
Sort map[string]string `key:"sort"`
}
m := map[string]any{
"sort": CustomStringer(`"value":"ascend","emptyStr":""`),
}
ast := assert.New(t)
if ast.NoError(UnmarshalKey(m, &v)) {
ast.Equal(2, len(v.Sort))
ast.Equal("ascend", v.Sort["value"])
ast.Equal("", v.Sort["emptyStr"])
}
ast := assert.New(t)
if ast.NoError(UnmarshalKey(m, &v)) {
ast.Equal(2, len(v.Sort))
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,48 +1071,83 @@ func TestUnmarshalStringSliceMapFromString(t *testing.T) {
}
func TestUnmarshalStruct(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": "400000",
},
}
t.Run("struct", 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": "400000",
},
}
var in inner
ast := assert.New(t)
if ast.NoError(UnmarshalKey(m, &in)) {
ast.Equal("kevin", in.Name)
ast.Equal("shanghai", in.Address.City)
ast.Equal(200000, in.Address.ZipCode)
ast.Equal("hello", in.AddressP.DefaultString)
ast.Equal("beijing", in.AddressP.City)
ast.Equal(300000, in.AddressP.ZipCode)
ast.Equal("hello", in.AddressP.DefaultString)
ast.Equal("guangzhou", (*in.AddressPP).City)
ast.Equal(400000, (*in.AddressPP).ZipCode)
ast.Equal("hello", (*in.AddressPP).DefaultString)
}
var in inner
ast := assert.New(t)
if ast.NoError(UnmarshalKey(m, &in)) {
ast.Equal("kevin", in.Name)
ast.Equal("shanghai", in.Address.City)
ast.Equal(200000, in.Address.ZipCode)
ast.Equal("hello", in.AddressP.DefaultString)
ast.Equal("beijing", in.AddressP.City)
ast.Equal(300000, in.AddressP.ZipCode)
ast.Equal("hello", in.AddressP.DefaultString)
ast.Equal("guangzhou", (*in.AddressPP).City)
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,21 +1286,44 @@ func TestUnmarshalStructOptionalDependsNot(t *testing.T) {
}
func TestUnmarshalStructOptionalDependsNotErrorDetails(t *testing.T) {
type address struct {
Optional string `key:",optional"`
OptionalDepends string `key:",optional=!Optional"`
}
type inner struct {
Name string `key:"name"`
Address address `key:"address"`
}
t.Run("mutal optionals", func(t *testing.T) {
type address struct {
Optional string `key:",optional"`
OptionalDepends string `key:",optional=!Optional"`
}
type inner struct {
Name string `key:"name"`
Address address `key:"address"`
}
m := map[string]any{
"name": "kevin",
}
m := map[string]any{
"name": "kevin",
}
var in inner
assert.Error(t, UnmarshalKey(m, &in))
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,16 +1663,48 @@ func TestUnmarshalMapOfInt(t *testing.T) {
}
}
func TestUnmarshalMapOfStructError(t *testing.T) {
m := map[string]any{
"Ids": map[string]any{"first": "second"},
}
var v struct {
Ids map[string]struct {
Name string
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"},
}
}
assert.Error(t, UnmarshalKey(m, &v))
var v struct {
Ids map[string]struct {
Name string
}
}
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,26 +1747,46 @@ func TestUnmarshalSlice(t *testing.T) {
}
func TestUnmarshalSliceOfStruct(t *testing.T) {
m := map[string]any{
"Ids": []map[string]any{
{
"First": 1,
"Second": 2,
t.Run("slice of struct", func(t *testing.T) {
m := map[string]any{
"Ids": []map[string]any{
{
"First": 1,
"Second": 2,
},
},
},
}
var v struct {
Ids []struct {
First int
Second int
}
}
ast := assert.New(t)
if ast.NoError(UnmarshalKey(m, &v)) {
ast.Equal(1, len(v.Ids))
ast.Equal(1, v.Ids[0].First)
ast.Equal(2, v.Ids[0].Second)
}
var v struct {
Ids []struct {
First int
Second int
}
}
ast := assert.New(t)
if ast.NoError(UnmarshalKey(m, &v)) {
ast.Equal(1, len(v.Ids))
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,21 +3397,57 @@ func TestUnmarshalRangeError(t *testing.T) {
}
func TestUnmarshalNestedMap(t *testing.T) {
var c struct {
Anything map[string]map[string]string `json:"anything"`
}
m := map[string]any{
"anything": map[string]map[string]any{
"inner": {
"id": "1",
"name": "any",
t.Run("nested map", func(t *testing.T) {
var c struct {
Anything map[string]map[string]string `json:"anything"`
}
m := map[string]any{
"anything": map[string]map[string]any{
"inner": {
"id": "1",
"name": "any",
},
},
},
}
}
if assert.NoError(t, NewUnmarshaler("json").Unmarshal(m, &c)) {
assert.Equal(t, "1", c.Anything["inner"]["id"])
}
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,15 +4121,27 @@ func TestUnmarshal_EnvWithOptionsWrongValueString(t *testing.T) {
}
func TestUnmarshalJsonReaderMultiArray(t *testing.T) {
var res struct {
A string `json:"a"`
B [][]string `json:"b"`
}
payload := `{"a": "133", "b": [["add", "cccd"], ["eeee"]]}`
reader := strings.NewReader(payload)
if assert.NoError(t, UnmarshalJsonReader(reader, &res)) {
assert.Equal(t, 2, len(res.B))
}
t.Run("reader multi array", func(t *testing.T) {
var res struct {
A string `json:"a"`
B [][]string `json:"b"`
}
payload := `{"a": "133", "b": [["add", "cccd"], ["eeee"]]}`
reader := strings.NewReader(payload)
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) {
var req struct {
Params map[string]string `json:"params"`
}
body := `{"params":{"a":{"a":123}}}`
assert.Equal(t, errTypeMismatch, UnmarshalJsonReader(strings.NewReader(body), &req))
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,43 +4412,95 @@ func TestUnmarshalJsonReaderWithMismatchType(t *testing.T) {
assert.Equal(t, errTypeMismatch, UnmarshalJsonReader(strings.NewReader(body), &req))
}
func TestUnmarshalJsonReaderWithMismatchTypeBool(t *testing.T) {
type Req struct {
Params map[string]bool `json:"params"`
}
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
}{
{
name: "int",
input: `{"params":{"a":123}}`,
},
{
name: "int",
input: `{"params":{"a":"123"}}`,
},
}
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
assert.Equal(t, errTypeMismatch, UnmarshalJsonReader(strings.NewReader(test.input), &req))
})
}
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"`
}
tests := []struct {
name string
input string
}{
{
name: "int",
input: `{"params":{"a":123}}`,
},
{
name: "int",
input: `{"params":{"a":"123"}}`,
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
var req Req
assert.Equal(t, errTypeMismatch, UnmarshalJsonReader(strings.NewReader(test.input), &req))
})
}
})
}
func TestUnmarshalJsonReaderWithMismatchTypeBoolMap(t *testing.T) {
var req struct {
Params map[string]string `json:"params"`
}
assert.Equal(t, errTypeMismatch, UnmarshalJsonMap(map[string]any{
"params": map[string]any{
"a": true,
},
}, &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)
}
})
t.Run("bool map with error", func(t *testing.T) {
var req struct {
Params map[string]string `json:"params"`
}
assert.Equal(t, errTypeMismatch, UnmarshalJsonMap(map[string]any{
"params": map[string]any{
"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