summaryrefslogtreecommitdiffstats
path: root/vendor/github.com/mitchellh/mapstructure/mapstructure_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/mitchellh/mapstructure/mapstructure_test.go')
-rw-r--r--vendor/github.com/mitchellh/mapstructure/mapstructure_test.go1708
1 files changed, 0 insertions, 1708 deletions
diff --git a/vendor/github.com/mitchellh/mapstructure/mapstructure_test.go b/vendor/github.com/mitchellh/mapstructure/mapstructure_test.go
deleted file mode 100644
index 64b122a9d..000000000
--- a/vendor/github.com/mitchellh/mapstructure/mapstructure_test.go
+++ /dev/null
@@ -1,1708 +0,0 @@
-package mapstructure
-
-import (
- "encoding/json"
- "io"
- "reflect"
- "sort"
- "strings"
- "testing"
-)
-
-type Basic struct {
- Vstring string
- Vint int
- Vuint uint
- Vbool bool
- Vfloat float64
- Vextra string
- vsilent bool
- Vdata interface{}
- VjsonInt int
- VjsonFloat float64
- VjsonNumber json.Number
-}
-
-type BasicSquash struct {
- Test Basic `mapstructure:",squash"`
-}
-
-type Embedded struct {
- Basic
- Vunique string
-}
-
-type EmbeddedPointer struct {
- *Basic
- Vunique string
-}
-
-type EmbeddedSquash struct {
- Basic `mapstructure:",squash"`
- Vunique string
-}
-
-type SliceAlias []string
-
-type EmbeddedSlice struct {
- SliceAlias `mapstructure:"slice_alias"`
- Vunique string
-}
-
-type ArrayAlias [2]string
-
-type EmbeddedArray struct {
- ArrayAlias `mapstructure:"array_alias"`
- Vunique string
-}
-
-type SquashOnNonStructType struct {
- InvalidSquashType int `mapstructure:",squash"`
-}
-
-type Map struct {
- Vfoo string
- Vother map[string]string
-}
-
-type MapOfStruct struct {
- Value map[string]Basic
-}
-
-type Nested struct {
- Vfoo string
- Vbar Basic
-}
-
-type NestedPointer struct {
- Vfoo string
- Vbar *Basic
-}
-
-type NilInterface struct {
- W io.Writer
-}
-
-type Slice struct {
- Vfoo string
- Vbar []string
-}
-
-type SliceOfStruct struct {
- Value []Basic
-}
-
-type Array struct {
- Vfoo string
- Vbar [2]string
-}
-
-type ArrayOfStruct struct {
- Value [2]Basic
-}
-
-type Func struct {
- Foo func() string
-}
-
-type Tagged struct {
- Extra string `mapstructure:"bar,what,what"`
- Value string `mapstructure:"foo"`
-}
-
-type TypeConversionResult struct {
- IntToFloat float32
- IntToUint uint
- IntToBool bool
- IntToString string
- UintToInt int
- UintToFloat float32
- UintToBool bool
- UintToString string
- BoolToInt int
- BoolToUint uint
- BoolToFloat float32
- BoolToString string
- FloatToInt int
- FloatToUint uint
- FloatToBool bool
- FloatToString string
- SliceUint8ToString string
- StringToSliceUint8 []byte
- ArrayUint8ToString string
- StringToInt int
- StringToUint uint
- StringToBool bool
- StringToFloat float32
- StringToStrSlice []string
- StringToIntSlice []int
- StringToStrArray [1]string
- StringToIntArray [1]int
- SliceToMap map[string]interface{}
- MapToSlice []interface{}
- ArrayToMap map[string]interface{}
- MapToArray [1]interface{}
-}
-
-func TestBasicTypes(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vstring": "foo",
- "vint": 42,
- "Vuint": 42,
- "vbool": true,
- "Vfloat": 42.42,
- "vsilent": true,
- "vdata": 42,
- "vjsonInt": json.Number("1234"),
- "vjsonFloat": json.Number("1234.5"),
- "vjsonNumber": json.Number("1234.5"),
- }
-
- var result Basic
- err := Decode(input, &result)
- if err != nil {
- t.Errorf("got an err: %s", err.Error())
- t.FailNow()
- }
-
- if result.Vstring != "foo" {
- t.Errorf("vstring value should be 'foo': %#v", result.Vstring)
- }
-
- if result.Vint != 42 {
- t.Errorf("vint value should be 42: %#v", result.Vint)
- }
-
- if result.Vuint != 42 {
- t.Errorf("vuint value should be 42: %#v", result.Vuint)
- }
-
- if result.Vbool != true {
- t.Errorf("vbool value should be true: %#v", result.Vbool)
- }
-
- if result.Vfloat != 42.42 {
- t.Errorf("vfloat value should be 42.42: %#v", result.Vfloat)
- }
-
- if result.Vextra != "" {
- t.Errorf("vextra value should be empty: %#v", result.Vextra)
- }
-
- if result.vsilent != false {
- t.Error("vsilent should not be set, it is unexported")
- }
-
- if result.Vdata != 42 {
- t.Error("vdata should be valid")
- }
-
- if result.VjsonInt != 1234 {
- t.Errorf("vjsonint value should be 1234: %#v", result.VjsonInt)
- }
-
- if result.VjsonFloat != 1234.5 {
- t.Errorf("vjsonfloat value should be 1234.5: %#v", result.VjsonFloat)
- }
-
- if !reflect.DeepEqual(result.VjsonNumber, json.Number("1234.5")) {
- t.Errorf("vjsonnumber value should be '1234.5': %T, %#v", result.VjsonNumber, result.VjsonNumber)
- }
-}
-
-func TestBasic_IntWithFloat(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vint": float64(42),
- }
-
- var result Basic
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got an err: %s", err)
- }
-}
-
-func TestBasic_Merge(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vint": 42,
- }
-
- var result Basic
- result.Vuint = 100
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got an err: %s", err)
- }
-
- expected := Basic{
- Vint: 42,
- Vuint: 100,
- }
- if !reflect.DeepEqual(result, expected) {
- t.Fatalf("bad: %#v", result)
- }
-}
-
-// Test for issue #46.
-func TestBasic_Struct(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vdata": map[string]interface{}{
- "vstring": "foo",
- },
- }
-
- var result, inner Basic
- result.Vdata = &inner
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got an err: %s", err)
- }
- expected := Basic{
- Vdata: &Basic{
- Vstring: "foo",
- },
- }
- if !reflect.DeepEqual(result, expected) {
- t.Fatalf("bad: %#v", result)
- }
-}
-
-func TestDecode_BasicSquash(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vstring": "foo",
- }
-
- var result BasicSquash
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got an err: %s", err.Error())
- }
-
- if result.Test.Vstring != "foo" {
- t.Errorf("vstring value should be 'foo': %#v", result.Test.Vstring)
- }
-}
-
-func TestDecode_Embedded(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vstring": "foo",
- "Basic": map[string]interface{}{
- "vstring": "innerfoo",
- },
- "vunique": "bar",
- }
-
- var result Embedded
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got an err: %s", err.Error())
- }
-
- if result.Vstring != "innerfoo" {
- t.Errorf("vstring value should be 'innerfoo': %#v", result.Vstring)
- }
-
- if result.Vunique != "bar" {
- t.Errorf("vunique value should be 'bar': %#v", result.Vunique)
- }
-}
-
-func TestDecode_EmbeddedPointer(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vstring": "foo",
- "Basic": map[string]interface{}{
- "vstring": "innerfoo",
- },
- "vunique": "bar",
- }
-
- var result EmbeddedPointer
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("err: %s", err)
- }
-
- expected := EmbeddedPointer{
- Basic: &Basic{
- Vstring: "innerfoo",
- },
- Vunique: "bar",
- }
- if !reflect.DeepEqual(result, expected) {
- t.Fatalf("bad: %#v", result)
- }
-}
-
-func TestDecode_EmbeddedSlice(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "slice_alias": []string{"foo", "bar"},
- "vunique": "bar",
- }
-
- var result EmbeddedSlice
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got an err: %s", err.Error())
- }
-
- if !reflect.DeepEqual(result.SliceAlias, SliceAlias([]string{"foo", "bar"})) {
- t.Errorf("slice value: %#v", result.SliceAlias)
- }
-
- if result.Vunique != "bar" {
- t.Errorf("vunique value should be 'bar': %#v", result.Vunique)
- }
-}
-
-func TestDecode_EmbeddedArray(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "array_alias": [2]string{"foo", "bar"},
- "vunique": "bar",
- }
-
- var result EmbeddedArray
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got an err: %s", err.Error())
- }
-
- if !reflect.DeepEqual(result.ArrayAlias, ArrayAlias([2]string{"foo", "bar"})) {
- t.Errorf("array value: %#v", result.ArrayAlias)
- }
-
- if result.Vunique != "bar" {
- t.Errorf("vunique value should be 'bar': %#v", result.Vunique)
- }
-}
-
-func TestDecode_EmbeddedSquash(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vstring": "foo",
- "vunique": "bar",
- }
-
- var result EmbeddedSquash
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got an err: %s", err.Error())
- }
-
- if result.Vstring != "foo" {
- t.Errorf("vstring value should be 'foo': %#v", result.Vstring)
- }
-
- if result.Vunique != "bar" {
- t.Errorf("vunique value should be 'bar': %#v", result.Vunique)
- }
-}
-
-func TestDecode_SquashOnNonStructType(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "InvalidSquashType": 42,
- }
-
- var result SquashOnNonStructType
- err := Decode(input, &result)
- if err == nil {
- t.Fatal("unexpected success decoding invalid squash field type")
- } else if !strings.Contains(err.Error(), "unsupported type for squash") {
- t.Fatalf("unexpected error message for invalid squash field type: %s", err)
- }
-}
-
-func TestDecode_DecodeHook(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vint": "WHAT",
- }
-
- decodeHook := func(from reflect.Kind, to reflect.Kind, v interface{}) (interface{}, error) {
- if from == reflect.String && to != reflect.String {
- return 5, nil
- }
-
- return v, nil
- }
-
- var result Basic
- config := &DecoderConfig{
- DecodeHook: decodeHook,
- Result: &result,
- }
-
- decoder, err := NewDecoder(config)
- if err != nil {
- t.Fatalf("err: %s", err)
- }
-
- err = decoder.Decode(input)
- if err != nil {
- t.Fatalf("got an err: %s", err)
- }
-
- if result.Vint != 5 {
- t.Errorf("vint should be 5: %#v", result.Vint)
- }
-}
-
-func TestDecode_DecodeHookType(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vint": "WHAT",
- }
-
- decodeHook := func(from reflect.Type, to reflect.Type, v interface{}) (interface{}, error) {
- if from.Kind() == reflect.String &&
- to.Kind() != reflect.String {
- return 5, nil
- }
-
- return v, nil
- }
-
- var result Basic
- config := &DecoderConfig{
- DecodeHook: decodeHook,
- Result: &result,
- }
-
- decoder, err := NewDecoder(config)
- if err != nil {
- t.Fatalf("err: %s", err)
- }
-
- err = decoder.Decode(input)
- if err != nil {
- t.Fatalf("got an err: %s", err)
- }
-
- if result.Vint != 5 {
- t.Errorf("vint should be 5: %#v", result.Vint)
- }
-}
-
-func TestDecode_Nil(t *testing.T) {
- t.Parallel()
-
- var input interface{}
- result := Basic{
- Vstring: "foo",
- }
-
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("err: %s", err)
- }
-
- if result.Vstring != "foo" {
- t.Fatalf("bad: %#v", result.Vstring)
- }
-}
-
-func TestDecode_NilInterfaceHook(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "w": "",
- }
-
- decodeHook := func(f, t reflect.Type, v interface{}) (interface{}, error) {
- if t.String() == "io.Writer" {
- return nil, nil
- }
-
- return v, nil
- }
-
- var result NilInterface
- config := &DecoderConfig{
- DecodeHook: decodeHook,
- Result: &result,
- }
-
- decoder, err := NewDecoder(config)
- if err != nil {
- t.Fatalf("err: %s", err)
- }
-
- err = decoder.Decode(input)
- if err != nil {
- t.Fatalf("got an err: %s", err)
- }
-
- if result.W != nil {
- t.Errorf("W should be nil: %#v", result.W)
- }
-}
-
-func TestDecode_FuncHook(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "foo": "baz",
- }
-
- decodeHook := func(f, t reflect.Type, v interface{}) (interface{}, error) {
- if t.Kind() != reflect.Func {
- return v, nil
- }
- val := v.(string)
- return func() string { return val }, nil
- }
-
- var result Func
- config := &DecoderConfig{
- DecodeHook: decodeHook,
- Result: &result,
- }
-
- decoder, err := NewDecoder(config)
- if err != nil {
- t.Fatalf("err: %s", err)
- }
-
- err = decoder.Decode(input)
- if err != nil {
- t.Fatalf("got an err: %s", err)
- }
-
- if result.Foo() != "baz" {
- t.Errorf("Foo call result should be 'baz': %s", result.Foo())
- }
-}
-
-func TestDecode_NonStruct(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "foo": "bar",
- "bar": "baz",
- }
-
- var result map[string]string
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("err: %s", err)
- }
-
- if result["foo"] != "bar" {
- t.Fatal("foo is not bar")
- }
-}
-
-func TestDecode_StructMatch(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vbar": Basic{
- Vstring: "foo",
- },
- }
-
- var result Nested
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got an err: %s", err.Error())
- }
-
- if result.Vbar.Vstring != "foo" {
- t.Errorf("bad: %#v", result)
- }
-}
-
-func TestDecode_TypeConversion(t *testing.T) {
- input := map[string]interface{}{
- "IntToFloat": 42,
- "IntToUint": 42,
- "IntToBool": 1,
- "IntToString": 42,
- "UintToInt": 42,
- "UintToFloat": 42,
- "UintToBool": 42,
- "UintToString": 42,
- "BoolToInt": true,
- "BoolToUint": true,
- "BoolToFloat": true,
- "BoolToString": true,
- "FloatToInt": 42.42,
- "FloatToUint": 42.42,
- "FloatToBool": 42.42,
- "FloatToString": 42.42,
- "SliceUint8ToString": []uint8("foo"),
- "StringToSliceUint8": "foo",
- "ArrayUint8ToString": [3]uint8{'f', 'o', 'o'},
- "StringToInt": "42",
- "StringToUint": "42",
- "StringToBool": "1",
- "StringToFloat": "42.42",
- "StringToStrSlice": "A",
- "StringToIntSlice": "42",
- "StringToStrArray": "A",
- "StringToIntArray": "42",
- "SliceToMap": []interface{}{},
- "MapToSlice": map[string]interface{}{},
- "ArrayToMap": []interface{}{},
- "MapToArray": map[string]interface{}{},
- }
-
- expectedResultStrict := TypeConversionResult{
- IntToFloat: 42.0,
- IntToUint: 42,
- UintToInt: 42,
- UintToFloat: 42,
- BoolToInt: 0,
- BoolToUint: 0,
- BoolToFloat: 0,
- FloatToInt: 42,
- FloatToUint: 42,
- }
-
- expectedResultWeak := TypeConversionResult{
- IntToFloat: 42.0,
- IntToUint: 42,
- IntToBool: true,
- IntToString: "42",
- UintToInt: 42,
- UintToFloat: 42,
- UintToBool: true,
- UintToString: "42",
- BoolToInt: 1,
- BoolToUint: 1,
- BoolToFloat: 1,
- BoolToString: "1",
- FloatToInt: 42,
- FloatToUint: 42,
- FloatToBool: true,
- FloatToString: "42.42",
- SliceUint8ToString: "foo",
- StringToSliceUint8: []byte("foo"),
- ArrayUint8ToString: "foo",
- StringToInt: 42,
- StringToUint: 42,
- StringToBool: true,
- StringToFloat: 42.42,
- StringToStrSlice: []string{"A"},
- StringToIntSlice: []int{42},
- StringToStrArray: [1]string{"A"},
- StringToIntArray: [1]int{42},
- SliceToMap: map[string]interface{}{},
- MapToSlice: []interface{}{},
- ArrayToMap: map[string]interface{}{},
- MapToArray: [1]interface{}{},
- }
-
- // Test strict type conversion
- var resultStrict TypeConversionResult
- err := Decode(input, &resultStrict)
- if err == nil {
- t.Errorf("should return an error")
- }
- if !reflect.DeepEqual(resultStrict, expectedResultStrict) {
- t.Errorf("expected %v, got: %v", expectedResultStrict, resultStrict)
- }
-
- // Test weak type conversion
- var decoder *Decoder
- var resultWeak TypeConversionResult
-
- config := &DecoderConfig{
- WeaklyTypedInput: true,
- Result: &resultWeak,
- }
-
- decoder, err = NewDecoder(config)
- if err != nil {
- t.Fatalf("err: %s", err)
- }
-
- err = decoder.Decode(input)
- if err != nil {
- t.Fatalf("got an err: %s", err)
- }
-
- if !reflect.DeepEqual(resultWeak, expectedResultWeak) {
- t.Errorf("expected \n%#v, got: \n%#v", expectedResultWeak, resultWeak)
- }
-}
-
-func TestDecoder_ErrorUnused(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vstring": "hello",
- "foo": "bar",
- }
-
- var result Basic
- config := &DecoderConfig{
- ErrorUnused: true,
- Result: &result,
- }
-
- decoder, err := NewDecoder(config)
- if err != nil {
- t.Fatalf("err: %s", err)
- }
-
- err = decoder.Decode(input)
- if err == nil {
- t.Fatal("expected error")
- }
-}
-
-func TestMap(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vfoo": "foo",
- "vother": map[interface{}]interface{}{
- "foo": "foo",
- "bar": "bar",
- },
- }
-
- var result Map
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got an error: %s", err)
- }
-
- if result.Vfoo != "foo" {
- t.Errorf("vfoo value should be 'foo': %#v", result.Vfoo)
- }
-
- if result.Vother == nil {
- t.Fatal("vother should not be nil")
- }
-
- if len(result.Vother) != 2 {
- t.Error("vother should have two items")
- }
-
- if result.Vother["foo"] != "foo" {
- t.Errorf("'foo' key should be foo, got: %#v", result.Vother["foo"])
- }
-
- if result.Vother["bar"] != "bar" {
- t.Errorf("'bar' key should be bar, got: %#v", result.Vother["bar"])
- }
-}
-
-func TestMapMerge(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vfoo": "foo",
- "vother": map[interface{}]interface{}{
- "foo": "foo",
- "bar": "bar",
- },
- }
-
- var result Map
- result.Vother = map[string]string{"hello": "world"}
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got an error: %s", err)
- }
-
- if result.Vfoo != "foo" {
- t.Errorf("vfoo value should be 'foo': %#v", result.Vfoo)
- }
-
- expected := map[string]string{
- "foo": "foo",
- "bar": "bar",
- "hello": "world",
- }
- if !reflect.DeepEqual(result.Vother, expected) {
- t.Errorf("bad: %#v", result.Vother)
- }
-}
-
-func TestMapOfStruct(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "value": map[string]interface{}{
- "foo": map[string]string{"vstring": "one"},
- "bar": map[string]string{"vstring": "two"},
- },
- }
-
- var result MapOfStruct
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got an err: %s", err)
- }
-
- if result.Value == nil {
- t.Fatal("value should not be nil")
- }
-
- if len(result.Value) != 2 {
- t.Error("value should have two items")
- }
-
- if result.Value["foo"].Vstring != "one" {
- t.Errorf("foo value should be 'one', got: %s", result.Value["foo"].Vstring)
- }
-
- if result.Value["bar"].Vstring != "two" {
- t.Errorf("bar value should be 'two', got: %s", result.Value["bar"].Vstring)
- }
-}
-
-func TestNestedType(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vfoo": "foo",
- "vbar": map[string]interface{}{
- "vstring": "foo",
- "vint": 42,
- "vbool": true,
- },
- }
-
- var result Nested
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got an err: %s", err.Error())
- }
-
- if result.Vfoo != "foo" {
- t.Errorf("vfoo value should be 'foo': %#v", result.Vfoo)
- }
-
- if result.Vbar.Vstring != "foo" {
- t.Errorf("vstring value should be 'foo': %#v", result.Vbar.Vstring)
- }
-
- if result.Vbar.Vint != 42 {
- t.Errorf("vint value should be 42: %#v", result.Vbar.Vint)
- }
-
- if result.Vbar.Vbool != true {
- t.Errorf("vbool value should be true: %#v", result.Vbar.Vbool)
- }
-
- if result.Vbar.Vextra != "" {
- t.Errorf("vextra value should be empty: %#v", result.Vbar.Vextra)
- }
-}
-
-func TestNestedTypePointer(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vfoo": "foo",
- "vbar": &map[string]interface{}{
- "vstring": "foo",
- "vint": 42,
- "vbool": true,
- },
- }
-
- var result NestedPointer
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got an err: %s", err.Error())
- }
-
- if result.Vfoo != "foo" {
- t.Errorf("vfoo value should be 'foo': %#v", result.Vfoo)
- }
-
- if result.Vbar.Vstring != "foo" {
- t.Errorf("vstring value should be 'foo': %#v", result.Vbar.Vstring)
- }
-
- if result.Vbar.Vint != 42 {
- t.Errorf("vint value should be 42: %#v", result.Vbar.Vint)
- }
-
- if result.Vbar.Vbool != true {
- t.Errorf("vbool value should be true: %#v", result.Vbar.Vbool)
- }
-
- if result.Vbar.Vextra != "" {
- t.Errorf("vextra value should be empty: %#v", result.Vbar.Vextra)
- }
-}
-
-// Test for issue #46.
-func TestNestedTypeInterface(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vfoo": "foo",
- "vbar": &map[string]interface{}{
- "vstring": "foo",
- "vint": 42,
- "vbool": true,
-
- "vdata": map[string]interface{}{
- "vstring": "bar",
- },
- },
- }
-
- var result NestedPointer
- result.Vbar = new(Basic)
- result.Vbar.Vdata = new(Basic)
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got an err: %s", err.Error())
- }
-
- if result.Vfoo != "foo" {
- t.Errorf("vfoo value should be 'foo': %#v", result.Vfoo)
- }
-
- if result.Vbar.Vstring != "foo" {
- t.Errorf("vstring value should be 'foo': %#v", result.Vbar.Vstring)
- }
-
- if result.Vbar.Vint != 42 {
- t.Errorf("vint value should be 42: %#v", result.Vbar.Vint)
- }
-
- if result.Vbar.Vbool != true {
- t.Errorf("vbool value should be true: %#v", result.Vbar.Vbool)
- }
-
- if result.Vbar.Vextra != "" {
- t.Errorf("vextra value should be empty: %#v", result.Vbar.Vextra)
- }
-
- if result.Vbar.Vdata.(*Basic).Vstring != "bar" {
- t.Errorf("vstring value should be 'bar': %#v", result.Vbar.Vdata.(*Basic).Vstring)
- }
-}
-
-func TestSlice(t *testing.T) {
- t.Parallel()
-
- inputStringSlice := map[string]interface{}{
- "vfoo": "foo",
- "vbar": []string{"foo", "bar", "baz"},
- }
-
- inputStringSlicePointer := map[string]interface{}{
- "vfoo": "foo",
- "vbar": &[]string{"foo", "bar", "baz"},
- }
-
- outputStringSlice := &Slice{
- "foo",
- []string{"foo", "bar", "baz"},
- }
-
- testSliceInput(t, inputStringSlice, outputStringSlice)
- testSliceInput(t, inputStringSlicePointer, outputStringSlice)
-}
-
-func TestInvalidSlice(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vfoo": "foo",
- "vbar": 42,
- }
-
- result := Slice{}
- err := Decode(input, &result)
- if err == nil {
- t.Errorf("expected failure")
- }
-}
-
-func TestSliceOfStruct(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "value": []map[string]interface{}{
- {"vstring": "one"},
- {"vstring": "two"},
- },
- }
-
- var result SliceOfStruct
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got unexpected error: %s", err)
- }
-
- if len(result.Value) != 2 {
- t.Fatalf("expected two values, got %d", len(result.Value))
- }
-
- if result.Value[0].Vstring != "one" {
- t.Errorf("first value should be 'one', got: %s", result.Value[0].Vstring)
- }
-
- if result.Value[1].Vstring != "two" {
- t.Errorf("second value should be 'two', got: %s", result.Value[1].Vstring)
- }
-}
-
-func TestSliceToMap(t *testing.T) {
- t.Parallel()
-
- input := []map[string]interface{}{
- {
- "foo": "bar",
- },
- {
- "bar": "baz",
- },
- }
-
- var result map[string]interface{}
- err := WeakDecode(input, &result)
- if err != nil {
- t.Fatalf("got an error: %s", err)
- }
-
- expected := map[string]interface{}{
- "foo": "bar",
- "bar": "baz",
- }
- if !reflect.DeepEqual(result, expected) {
- t.Errorf("bad: %#v", result)
- }
-}
-
-func TestArray(t *testing.T) {
- t.Parallel()
-
- inputStringArray := map[string]interface{}{
- "vfoo": "foo",
- "vbar": [2]string{"foo", "bar"},
- }
-
- inputStringArrayPointer := map[string]interface{}{
- "vfoo": "foo",
- "vbar": &[2]string{"foo", "bar"},
- }
-
- outputStringArray := &Array{
- "foo",
- [2]string{"foo", "bar"},
- }
-
- testArrayInput(t, inputStringArray, outputStringArray)
- testArrayInput(t, inputStringArrayPointer, outputStringArray)
-}
-
-func TestInvalidArray(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vfoo": "foo",
- "vbar": 42,
- }
-
- result := Array{}
- err := Decode(input, &result)
- if err == nil {
- t.Errorf("expected failure")
- }
-}
-
-func TestArrayOfStruct(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "value": []map[string]interface{}{
- {"vstring": "one"},
- {"vstring": "two"},
- },
- }
-
- var result ArrayOfStruct
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got unexpected error: %s", err)
- }
-
- if len(result.Value) != 2 {
- t.Fatalf("expected two values, got %d", len(result.Value))
- }
-
- if result.Value[0].Vstring != "one" {
- t.Errorf("first value should be 'one', got: %s", result.Value[0].Vstring)
- }
-
- if result.Value[1].Vstring != "two" {
- t.Errorf("second value should be 'two', got: %s", result.Value[1].Vstring)
- }
-}
-
-func TestArrayToMap(t *testing.T) {
- t.Parallel()
-
- input := []map[string]interface{}{
- {
- "foo": "bar",
- },
- {
- "bar": "baz",
- },
- }
-
- var result map[string]interface{}
- err := WeakDecode(input, &result)
- if err != nil {
- t.Fatalf("got an error: %s", err)
- }
-
- expected := map[string]interface{}{
- "foo": "bar",
- "bar": "baz",
- }
- if !reflect.DeepEqual(result, expected) {
- t.Errorf("bad: %#v", result)
- }
-}
-
-func TestMapOutputForStructuredInputs(t *testing.T) {
- t.Parallel()
-
- tests := []struct {
- name string
- in interface{}
- target interface{}
- out interface{}
- wantErr bool
- }{
- {
- "basic struct input",
- &Basic{
- Vstring: "vstring",
- Vint: 2,
- Vuint: 3,
- Vbool: true,
- Vfloat: 4.56,
- Vextra: "vextra",
- vsilent: true,
- Vdata: []byte("data"),
- },
- &map[string]interface{}{},
- &map[string]interface{}{
- "Vstring": "vstring",
- "Vint": 2,
- "Vuint": uint(3),
- "Vbool": true,
- "Vfloat": 4.56,
- "Vextra": "vextra",
- "Vdata": []byte("data"),
- "VjsonInt": 0,
- "VjsonFloat": 0.0,
- "VjsonNumber": json.Number(""),
- },
- false,
- },
- {
- "embedded struct input",
- &Embedded{
- Vunique: "vunique",
- Basic: Basic{
- Vstring: "vstring",
- Vint: 2,
- Vuint: 3,
- Vbool: true,
- Vfloat: 4.56,
- Vextra: "vextra",
- vsilent: true,
- Vdata: []byte("data"),
- },
- },
- &map[string]interface{}{},
- &map[string]interface{}{
- "Vunique": "vunique",
- "Basic": map[string]interface{}{
- "Vstring": "vstring",
- "Vint": 2,
- "Vuint": uint(3),
- "Vbool": true,
- "Vfloat": 4.56,
- "Vextra": "vextra",
- "Vdata": []byte("data"),
- "VjsonInt": 0,
- "VjsonFloat": 0.0,
- "VjsonNumber": json.Number(""),
- },
- },
- false,
- },
- {
- "slice input - should error",
- []string{"foo", "bar"},
- &map[string]interface{}{},
- &map[string]interface{}{},
- true,
- },
- {
- "struct with slice property",
- &Slice{
- Vfoo: "vfoo",
- Vbar: []string{"foo", "bar"},
- },
- &map[string]interface{}{},
- &map[string]interface{}{
- "Vfoo": "vfoo",
- "Vbar": []string{"foo", "bar"},
- },
- false,
- },
- {
- "struct with slice of struct property",
- &SliceOfStruct{
- Value: []Basic{
- Basic{
- Vstring: "vstring",
- Vint: 2,
- Vuint: 3,
- Vbool: true,
- Vfloat: 4.56,
- Vextra: "vextra",
- vsilent: true,
- Vdata: []byte("data"),
- },
- },
- },
- &map[string]interface{}{},
- &map[string]interface{}{
- "Value": []Basic{
- Basic{
- Vstring: "vstring",
- Vint: 2,
- Vuint: 3,
- Vbool: true,
- Vfloat: 4.56,
- Vextra: "vextra",
- vsilent: true,
- Vdata: []byte("data"),
- },
- },
- },
- false,
- },
- {
- "struct with map property",
- &Map{
- Vfoo: "vfoo",
- Vother: map[string]string{"vother": "vother"},
- },
- &map[string]interface{}{},
- &map[string]interface{}{
- "Vfoo": "vfoo",
- "Vother": map[string]string{
- "vother": "vother",
- }},
- false,
- },
- {
- "tagged struct",
- &Tagged{
- Extra: "extra",
- Value: "value",
- },
- &map[string]string{},
- &map[string]string{
- "bar": "extra",
- "foo": "value",
- },
- false,
- },
- {
- "omit tag struct",
- &struct {
- Value string `mapstructure:"value"`
- Omit string `mapstructure:"-"`
- }{
- Value: "value",
- Omit: "omit",
- },
- &map[string]string{},
- &map[string]string{
- "value": "value",
- },
- false,
- },
- {
- "decode to wrong map type",
- &struct {
- Value string
- }{
- Value: "string",
- },
- &map[string]int{},
- &map[string]int{},
- true,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- if err := Decode(tt.in, tt.target); (err != nil) != tt.wantErr {
- t.Fatalf("%q: TestMapOutputForStructuredInputs() unexpected error: %s", tt.name, err)
- }
-
- if !reflect.DeepEqual(tt.out, tt.target) {
- t.Fatalf("%q: TestMapOutputForStructuredInputs() expected: %#v, got: %#v", tt.name, tt.out, tt.target)
- }
- })
- }
-}
-
-func TestInvalidType(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vstring": 42,
- }
-
- var result Basic
- err := Decode(input, &result)
- if err == nil {
- t.Fatal("error should exist")
- }
-
- derr, ok := err.(*Error)
- if !ok {
- t.Fatalf("error should be kind of Error, instead: %#v", err)
- }
-
- if derr.Errors[0] != "'Vstring' expected type 'string', got unconvertible type 'int'" {
- t.Errorf("got unexpected error: %s", err)
- }
-
- inputNegIntUint := map[string]interface{}{
- "vuint": -42,
- }
-
- err = Decode(inputNegIntUint, &result)
- if err == nil {
- t.Fatal("error should exist")
- }
-
- derr, ok = err.(*Error)
- if !ok {
- t.Fatalf("error should be kind of Error, instead: %#v", err)
- }
-
- if derr.Errors[0] != "cannot parse 'Vuint', -42 overflows uint" {
- t.Errorf("got unexpected error: %s", err)
- }
-
- inputNegFloatUint := map[string]interface{}{
- "vuint": -42.0,
- }
-
- err = Decode(inputNegFloatUint, &result)
- if err == nil {
- t.Fatal("error should exist")
- }
-
- derr, ok = err.(*Error)
- if !ok {
- t.Fatalf("error should be kind of Error, instead: %#v", err)
- }
-
- if derr.Errors[0] != "cannot parse 'Vuint', -42.000000 overflows uint" {
- t.Errorf("got unexpected error: %s", err)
- }
-}
-
-func TestDecodeMetadata(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vfoo": "foo",
- "vbar": map[string]interface{}{
- "vstring": "foo",
- "Vuint": 42,
- "foo": "bar",
- },
- "bar": "nil",
- }
-
- var md Metadata
- var result Nested
-
- err := DecodeMetadata(input, &result, &md)
- if err != nil {
- t.Fatalf("err: %s", err.Error())
- }
-
- expectedKeys := []string{"Vbar", "Vbar.Vstring", "Vbar.Vuint", "Vfoo"}
- sort.Strings(md.Keys)
- if !reflect.DeepEqual(md.Keys, expectedKeys) {
- t.Fatalf("bad keys: %#v", md.Keys)
- }
-
- expectedUnused := []string{"Vbar.foo", "bar"}
- if !reflect.DeepEqual(md.Unused, expectedUnused) {
- t.Fatalf("bad unused: %#v", md.Unused)
- }
-}
-
-func TestMetadata(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vfoo": "foo",
- "vbar": map[string]interface{}{
- "vstring": "foo",
- "Vuint": 42,
- "foo": "bar",
- },
- "bar": "nil",
- }
-
- var md Metadata
- var result Nested
- config := &DecoderConfig{
- Metadata: &md,
- Result: &result,
- }
-
- decoder, err := NewDecoder(config)
- if err != nil {
- t.Fatalf("err: %s", err)
- }
-
- err = decoder.Decode(input)
- if err != nil {
- t.Fatalf("err: %s", err.Error())
- }
-
- expectedKeys := []string{"Vbar", "Vbar.Vstring", "Vbar.Vuint", "Vfoo"}
- sort.Strings(md.Keys)
- if !reflect.DeepEqual(md.Keys, expectedKeys) {
- t.Fatalf("bad keys: %#v", md.Keys)
- }
-
- expectedUnused := []string{"Vbar.foo", "bar"}
- if !reflect.DeepEqual(md.Unused, expectedUnused) {
- t.Fatalf("bad unused: %#v", md.Unused)
- }
-}
-
-func TestMetadata_Embedded(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "vstring": "foo",
- "vunique": "bar",
- }
-
- var md Metadata
- var result EmbeddedSquash
- config := &DecoderConfig{
- Metadata: &md,
- Result: &result,
- }
-
- decoder, err := NewDecoder(config)
- if err != nil {
- t.Fatalf("err: %s", err)
- }
-
- err = decoder.Decode(input)
- if err != nil {
- t.Fatalf("err: %s", err.Error())
- }
-
- expectedKeys := []string{"Vstring", "Vunique"}
-
- sort.Strings(md.Keys)
- if !reflect.DeepEqual(md.Keys, expectedKeys) {
- t.Fatalf("bad keys: %#v", md.Keys)
- }
-
- expectedUnused := []string{}
- if !reflect.DeepEqual(md.Unused, expectedUnused) {
- t.Fatalf("bad unused: %#v", md.Unused)
- }
-}
-
-func TestNonPtrValue(t *testing.T) {
- t.Parallel()
-
- err := Decode(map[string]interface{}{}, Basic{})
- if err == nil {
- t.Fatal("error should exist")
- }
-
- if err.Error() != "result must be a pointer" {
- t.Errorf("got unexpected error: %s", err)
- }
-}
-
-func TestTagged(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "foo": "bar",
- "bar": "value",
- }
-
- var result Tagged
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("unexpected error: %s", err)
- }
-
- if result.Value != "bar" {
- t.Errorf("value should be 'bar', got: %#v", result.Value)
- }
-
- if result.Extra != "value" {
- t.Errorf("extra should be 'value', got: %#v", result.Extra)
- }
-}
-
-func TestWeakDecode(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "foo": "4",
- "bar": "value",
- }
-
- var result struct {
- Foo int
- Bar string
- }
-
- if err := WeakDecode(input, &result); err != nil {
- t.Fatalf("err: %s", err)
- }
- if result.Foo != 4 {
- t.Fatalf("bad: %#v", result)
- }
- if result.Bar != "value" {
- t.Fatalf("bad: %#v", result)
- }
-}
-
-func TestWeakDecodeMetadata(t *testing.T) {
- t.Parallel()
-
- input := map[string]interface{}{
- "foo": "4",
- "bar": "value",
- "unused": "value",
- }
-
- var md Metadata
- var result struct {
- Foo int
- Bar string
- }
-
- if err := WeakDecodeMetadata(input, &result, &md); err != nil {
- t.Fatalf("err: %s", err)
- }
- if result.Foo != 4 {
- t.Fatalf("bad: %#v", result)
- }
- if result.Bar != "value" {
- t.Fatalf("bad: %#v", result)
- }
-
- expectedKeys := []string{"Bar", "Foo"}
- sort.Strings(md.Keys)
- if !reflect.DeepEqual(md.Keys, expectedKeys) {
- t.Fatalf("bad keys: %#v", md.Keys)
- }
-
- expectedUnused := []string{"unused"}
- if !reflect.DeepEqual(md.Unused, expectedUnused) {
- t.Fatalf("bad unused: %#v", md.Unused)
- }
-}
-
-func testSliceInput(t *testing.T, input map[string]interface{}, expected *Slice) {
- var result Slice
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got error: %s", err)
- }
-
- if result.Vfoo != expected.Vfoo {
- t.Errorf("Vfoo expected '%s', got '%s'", expected.Vfoo, result.Vfoo)
- }
-
- if result.Vbar == nil {
- t.Fatalf("Vbar a slice, got '%#v'", result.Vbar)
- }
-
- if len(result.Vbar) != len(expected.Vbar) {
- t.Errorf("Vbar length should be %d, got %d", len(expected.Vbar), len(result.Vbar))
- }
-
- for i, v := range result.Vbar {
- if v != expected.Vbar[i] {
- t.Errorf(
- "Vbar[%d] should be '%#v', got '%#v'",
- i, expected.Vbar[i], v)
- }
- }
-}
-
-func testArrayInput(t *testing.T, input map[string]interface{}, expected *Array) {
- var result Array
- err := Decode(input, &result)
- if err != nil {
- t.Fatalf("got error: %s", err)
- }
-
- if result.Vfoo != expected.Vfoo {
- t.Errorf("Vfoo expected '%s', got '%s'", expected.Vfoo, result.Vfoo)
- }
-
- if result.Vbar == [2]string{} {
- t.Fatalf("Vbar a slice, got '%#v'", result.Vbar)
- }
-
- if len(result.Vbar) != len(expected.Vbar) {
- t.Errorf("Vbar length should be %d, got %d", len(expected.Vbar), len(result.Vbar))
- }
-
- for i, v := range result.Vbar {
- if v != expected.Vbar[i] {
- t.Errorf(
- "Vbar[%d] should be '%#v', got '%#v'",
- i, expected.Vbar[i], v)
- }
- }
-}
generated by cgit v1.2.3-1-g7c22 (git 2.25.1) at 2024-09-29 19:52:04 +0000