From 9ebc15c9054801e1109b9985df3d12a9046d6c3c Mon Sep 17 00:00:00 2001 From: Xavier Vello Date: Wed, 14 Feb 2018 17:36:58 +0100 Subject: [PATCH 1/8] Add support for maps defined as a json string --- cast_test.go | 22 ++++++++++++++++++++++ caste.go | 20 ++++++++++++++++++++ 2 files changed, 42 insertions(+) diff --git a/cast_test.go b/cast_test.go index 404fe76..9f1b1f1 100644 --- a/cast_test.go +++ b/cast_test.go @@ -697,6 +697,10 @@ func TestStringMapStringSliceE(t *testing.T) { var stringMapInterface1 = map[string]interface{}{"key 1": []string{"value 1"}, "key 2": []string{"value 2"}} var stringMapInterfaceResult1 = map[string][]string{"key 1": {"value 1"}, "key 2": {"value 2"}} + var jsonStringMapString = `{"key 1": "value 1", "key 2": "value 2"}` + var jsonStringMapStringArray = `{"key 1": ["value 1"], "key 2": ["value 2", "value 3"]}` + var jsonStringMapStringArrayResult = map[string][]string{"key 1": {"value 1"}, "key 2": {"value 2", "value 3"}} + type Key struct { k string } @@ -718,11 +722,15 @@ func TestStringMapStringSliceE(t *testing.T) { {interfaceMapInterfaceSlice, stringMapStringSlice, false}, {interfaceMapString, stringMapStringSingleSliceFieldsResult, false}, {interfaceMapInterface, stringMapStringSingleSliceFieldsResult, false}, + {jsonStringMapStringArray, jsonStringMapStringArrayResult, false}, + // errors {nil, nil, true}, {testing.T{}, nil, true}, {map[interface{}]interface{}{"foo": testing.T{}}, nil, true}, {map[interface{}]interface{}{Key{"foo"}: "bar"}, nil, true}, // ToStringE(Key{"foo"}) should fail + {jsonStringMapString, nil, true}, + {"", nil, true}, } for i, test := range tests { @@ -751,9 +759,13 @@ func TestToStringMapE(t *testing.T) { }{ {map[interface{}]interface{}{"tag": "tags", "group": "groups"}, map[string]interface{}{"tag": "tags", "group": "groups"}, false}, {map[string]interface{}{"tag": "tags", "group": "groups"}, map[string]interface{}{"tag": "tags", "group": "groups"}, false}, + {`{"tag": "tags", "group": "groups"}`, map[string]interface{}{"tag": "tags", "group": "groups"}, false}, + {`{"tag": "tags", "group": true}`, map[string]interface{}{"tag": "tags", "group": true}, false}, + // errors {nil, nil, true}, {testing.T{}, nil, true}, + {"", nil, true}, } for i, test := range tests { @@ -783,9 +795,12 @@ func TestToStringMapBoolE(t *testing.T) { {map[interface{}]interface{}{"v1": true, "v2": false}, map[string]bool{"v1": true, "v2": false}, false}, {map[string]interface{}{"v1": true, "v2": false}, map[string]bool{"v1": true, "v2": false}, false}, {map[string]bool{"v1": true, "v2": false}, map[string]bool{"v1": true, "v2": false}, false}, + {`{"v1": true, "v2": false}`, map[string]bool{"v1": true, "v2": false}, false}, + // errors {nil, nil, true}, {testing.T{}, nil, true}, + {"", nil, true}, } for i, test := range tests { @@ -811,6 +826,9 @@ func TestToStringMapStringE(t *testing.T) { var stringMapInterface = map[string]interface{}{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"} var interfaceMapString = map[interface{}]string{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"} var interfaceMapInterface = map[interface{}]interface{}{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"} + var jsonString = `{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"}` + var invalidJsonString = `{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"` + var emptyString = "" tests := []struct { input interface{} @@ -821,9 +839,13 @@ func TestToStringMapStringE(t *testing.T) { {stringMapInterface, stringMapString, false}, {interfaceMapString, stringMapString, false}, {interfaceMapInterface, stringMapString, false}, + {jsonString, stringMapString, false}, + // errors {nil, nil, true}, {testing.T{}, nil, true}, + {invalidJsonString, nil, true}, + {emptyString, nil, true}, } for i, test := range tests { diff --git a/caste.go b/caste.go index 81511fe..4fe1928 100644 --- a/caste.go +++ b/caste.go @@ -6,6 +6,7 @@ package cast import ( + "encoding/json" "errors" "fmt" "html/template" @@ -872,6 +873,9 @@ func ToStringMapStringE(i interface{}) (map[string]string, error) { m[ToString(k)] = ToString(val) } return m, nil + case string: + err := jsonStringToObject(v, &m) + return m, err default: return m, fmt.Errorf("unable to cast %#v of type %T to map[string]string", i, i) } @@ -932,6 +936,9 @@ func ToStringMapStringSliceE(i interface{}) (map[string][]string, error) { } m[key] = value } + case string: + err := jsonStringToObject(v, &m) + return m, err default: return m, fmt.Errorf("unable to cast %#v of type %T to map[string][]string", i, i) } @@ -955,6 +962,9 @@ func ToStringMapBoolE(i interface{}) (map[string]bool, error) { return m, nil case map[string]bool: return v, nil + case string: + err := jsonStringToObject(v, &m) + return m, err default: return m, fmt.Errorf("unable to cast %#v of type %T to map[string]bool", i, i) } @@ -972,6 +982,9 @@ func ToStringMapE(i interface{}) (map[string]interface{}, error) { return m, nil case map[string]interface{}: return v, nil + case string: + err := jsonStringToObject(v, &m) + return m, err default: return m, fmt.Errorf("unable to cast %#v of type %T to map[string]interface{}", i, i) } @@ -1144,3 +1157,10 @@ func parseDateWith(s string, dates []string) (d time.Time, e error) { } return d, fmt.Errorf("unable to parse date: %s", s) } + +// jsonStringToObject attempts to unmarshall a string as JSON into +// the object passed as pointer. +func jsonStringToObject(s string, v interface{}) error { + data := []byte(s) + return json.Unmarshal(data, v) +} From 8965335b8c7107321228e3e3702cab9832751bac Mon Sep 17 00:00:00 2001 From: Xavier Vello Date: Wed, 14 Feb 2018 18:35:30 +0100 Subject: [PATCH 2/8] Add TestToDurationSliceE cases to reach 100% coverage --- cast_test.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/cast_test.go b/cast_test.go index 9f1b1f1..d9b0b01 100644 --- a/cast_test.go +++ b/cast_test.go @@ -1006,9 +1006,12 @@ func TestToDurationSliceE(t *testing.T) { {[]string{"1s", "1m"}, []time.Duration{time.Second, time.Minute}, false}, {[]int{1, 2}, []time.Duration{1, 2}, false}, {[]interface{}{1, 3}, []time.Duration{1, 3}, false}, + {[]time.Duration{1, 3}, []time.Duration{1, 3}, false}, + // errors {nil, nil, true}, {testing.T{}, nil, true}, + {[]string{"invalid"}, nil, true}, } for i, test := range tests { From 8934aa3ddd37816fba99744d49b0fd827b4bc3fb Mon Sep 17 00:00:00 2001 From: Ben Orchard Date: Sun, 21 Oct 2018 22:03:01 +0200 Subject: [PATCH 3/8] StringToDate: +more RFC3339 forms without TZ colon Adds a form to handle the common format `strftime("%FT%T%z")`, which omits the (optional) colon from the timezone. Also adds a matching T-omitted form. --- caste.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/caste.go b/caste.go index 4fe1928..0d4f2e2 100644 --- a/caste.go +++ b/caste.go @@ -1137,9 +1137,11 @@ func StringToDate(s string) (time.Time, error) { "2006-01-02 15:04:05.999999999 -0700 MST", // Time.String() "2006-01-02", "02 Jan 2006", + "2006-01-02T15:04:05-0700", // RFC3339 without timezone hh:mm colon "2006-01-02 15:04:05 -07:00", "2006-01-02 15:04:05 -0700", "2006-01-02 15:04:05Z07:00", // RFC3339 without T + "2006-01-02 15:04:05Z0700", // RFC3339 without T or timezone hh:mm colon "2006-01-02 15:04:05", time.Kitchen, time.Stamp, From efb632f0f61348654b631fd11da5ff457a5ca2ef Mon Sep 17 00:00:00 2001 From: Ben Orchard Date: Sun, 21 Oct 2018 23:22:53 +0200 Subject: [PATCH 4/8] tests: +date tests for RFC3339 no TZ colon cases --- cast_test.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/cast_test.go b/cast_test.go index d9b0b01..54066dd 100644 --- a/cast_test.go +++ b/cast_test.go @@ -1112,6 +1112,7 @@ func TestToTimeEE(t *testing.T) { {"Tue, 10 Nov 2009 23:00:00 UTC", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false}, // RFC1123 {"Tue, 10 Nov 2009 23:00:00 +0000", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false}, // RFC1123Z {"2009-11-10T23:00:00Z", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false}, // RFC3339 + {"2018-10-21T23:21:29+0200", time.Date(2018, 10, 21, 21, 21, 29, 0, time.UTC), false}, // RFC3339 without timezone hh:mm colon {"2009-11-10T23:00:00Z", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false}, // RFC3339Nano {"11:00PM", time.Date(0, 1, 1, 23, 0, 0, 0, time.UTC), false}, // Kitchen {"Nov 10 23:00:00", time.Date(0, 11, 10, 23, 0, 0, 0, time.UTC), false}, // Stamp @@ -1119,6 +1120,7 @@ func TestToTimeEE(t *testing.T) { {"Nov 10 23:00:00.000000", time.Date(0, 11, 10, 23, 0, 0, 0, time.UTC), false}, // StampMicro {"Nov 10 23:00:00.000000000", time.Date(0, 11, 10, 23, 0, 0, 0, time.UTC), false}, // StampNano {"2016-03-06 15:28:01-00:00", time.Date(2016, 3, 6, 15, 28, 1, 0, time.UTC), false}, // RFC3339 without T + {"2016-03-06 15:28:01-0000", time.Date(2016, 3, 6, 15, 28, 1, 0, time.UTC), false}, // RFC3339 without T or timezone hh:mm colon {"2016-03-06 15:28:01", time.Date(2016, 3, 6, 15, 28, 1, 0, time.UTC), false}, {"2016-03-06 15:28:01 -0000", time.Date(2016, 3, 6, 15, 28, 1, 0, time.UTC), false}, {"2016-03-06 15:28:01 -00:00", time.Date(2016, 3, 6, 15, 28, 1, 0, time.UTC), false}, From 4dd38b8b575fffe5096be8b5add8cea0b5779b4f Mon Sep 17 00:00:00 2001 From: Theofanis Despoudis Date: Wed, 24 Oct 2018 19:00:14 +0100 Subject: [PATCH 5/8] Add support for map of int64 and map of int --- cast.go | 12 ++++++++ cast_test.go | 77 +++++++++++++++++++++++++++++++++++++++++++++++++ caste.go | 81 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 170 insertions(+) diff --git a/cast.go b/cast.go index 8b8c208..9fba638 100644 --- a/cast.go +++ b/cast.go @@ -122,6 +122,18 @@ func ToStringMapBool(i interface{}) map[string]bool { return v } +// ToStringMapInt casts an interface to a map[string]int type. +func ToStringMapInt(i interface{}) map[string]int { + v, _ := ToStringMapIntE(i) + return v +} + +// ToStringMapInt64 casts an interface to a map[string]int64 type. +func ToStringMapInt64(i interface{}) map[string]int64 { + v, _ := ToStringMapInt64E(i) + return v +} + // ToStringMap casts an interface to a map[string]interface{} type. func ToStringMap(i interface{}) map[string]interface{} { v, _ := ToStringMapE(i) diff --git a/cast_test.go b/cast_test.go index 54066dd..1660ed0 100644 --- a/cast_test.go +++ b/cast_test.go @@ -821,6 +821,83 @@ func TestToStringMapBoolE(t *testing.T) { } } +func TestToStringMapIntE(t *testing.T) { + tests := []struct { + input interface{} + expect map[string]int + iserr bool + }{ + {map[interface{}]interface{}{"v1": 1, "v2": 222}, map[string]int{"v1": 1, "v2": 222}, false}, + {map[string]interface{}{"v1": 342, "v2": 5141}, map[string]int{"v1": 342, "v2": 5141}, false}, + {map[string]int{"v1": 33, "v2": 88}, map[string]int{"v1": 33, "v2": 88}, false}, + {map[string]int32{"v1": int32(33), "v2": int32(88)}, map[string]int{"v1": 33, "v2": 88}, false}, + {map[string]uint16{"v1": uint16(33), "v2": uint16(88)}, map[string]int{"v1": 33, "v2": 88}, false}, + {map[string]float64{"v1": float64(8.22), "v2": float64(43.32)}, map[string]int{"v1": 8, "v2": 43}, false}, + {`{"v1": 67, "v2": 56}`, map[string]int{"v1": 67, "v2": 56}, false}, + + // errors + {nil, nil, true}, + {testing.T{}, nil, true}, + {"", nil, true}, + } + + for i, test := range tests { + errmsg := fmt.Sprintf("i = %d", i) // assert helper message + + v, err := ToStringMapIntE(test.input) + if test.iserr { + assert.Error(t, err, errmsg) + continue + } + + assert.NoError(t, err, errmsg) + assert.Equal(t, test.expect, v, errmsg) + + // Non-E test + v = ToStringMapInt(test.input) + assert.Equal(t, test.expect, v, errmsg) + } +} + +func TestToStringMapInt64E(t *testing.T) { + tests := []struct { + input interface{} + expect map[string]int64 + iserr bool + }{ + {map[interface{}]interface{}{"v1": int32(8), "v2": int32(888)}, map[string]int64{"v1": int64(8), "v2": int64(888)}, false}, + {map[string]interface{}{"v1": int64(45), "v2": int64(67)}, map[string]int64{"v1": 45, "v2": 67}, false}, + {map[string]int64{"v1": 33, "v2": 88}, map[string]int64{"v1": 33, "v2": 88}, false}, + {map[string]int{"v1": 33, "v2": 88}, map[string]int64{"v1": 33, "v2": 88}, false}, + {map[string]int32{"v1": int32(33), "v2": int32(88)}, map[string]int64{"v1": 33, "v2": 88}, false}, + {map[string]uint16{"v1": uint16(33), "v2": uint16(88)}, map[string]int64{"v1": 33, "v2": 88}, false}, + {map[string]float64{"v1": float64(8.22), "v2": float64(43.32)}, map[string]int64{"v1": 8, "v2": 43}, false}, + {`{"v1": 67, "v2": 56}`, map[string]int64{"v1": 67, "v2": 56}, false}, + + // errors + {nil, nil, true}, + {testing.T{}, nil, true}, + {"", nil, true}, + } + + for i, test := range tests { + errmsg := fmt.Sprintf("i = %d", i) // assert helper message + + v, err := ToStringMapInt64E(test.input) + if test.iserr { + assert.Error(t, err, errmsg) + continue + } + + assert.NoError(t, err, errmsg) + assert.Equal(t, test.expect, v, errmsg) + + // Non-E test + v = ToStringMapInt64(test.input) + assert.Equal(t, test.expect, v, errmsg) + } +} + func TestToStringMapStringE(t *testing.T) { var stringMapString = map[string]string{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"} var stringMapInterface = map[string]interface{}{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"} diff --git a/caste.go b/caste.go index 0d4f2e2..81623c6 100644 --- a/caste.go +++ b/caste.go @@ -990,6 +990,87 @@ func ToStringMapE(i interface{}) (map[string]interface{}, error) { } } +// ToStringMapIntE casts an interface to a map[string]int{} type. +func ToStringMapIntE(i interface{}) (map[string]int, error) { + var m = map[string]int{} + if i == nil { + return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int", i, i) + } + + switch v := i.(type) { + case map[interface{}]interface{}: + for k, val := range v { + m[ToString(k)] = ToInt(val) + } + return m, nil + case map[string]interface{}: + for k, val := range v { + m[k] = ToInt(val) + } + return m, nil + case map[string]int: + return v, nil + case string: + err := jsonStringToObject(v, &m) + return m, err + } + + if reflect.TypeOf(i).Kind() != reflect.Map { + return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int", i, i) + } + + mVal := reflect.ValueOf(m) + v := reflect.ValueOf(i) + for _, keyVal := range v.MapKeys() { + val, err := ToIntE(v.MapIndex(keyVal).Interface()) + if err != nil { + return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int", i, i) + } + mVal.SetMapIndex(keyVal, reflect.ValueOf(val)) + } + return m, nil +} + +// ToStringMapInt64E casts an interface to a map[string]int64{} type. +func ToStringMapInt64E(i interface{}) (map[string]int64, error) { + var m = map[string]int64{} + if i == nil { + return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int64", i, i) + } + + switch v := i.(type) { + case map[interface{}]interface{}: + for k, val := range v { + m[ToString(k)] = ToInt64(val) + } + return m, nil + case map[string]interface{}: + for k, val := range v { + m[k] = ToInt64(val) + } + return m, nil + case map[string]int64: + return v, nil + case string: + err := jsonStringToObject(v, &m) + return m, err + } + + if reflect.TypeOf(i).Kind() != reflect.Map { + return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int64", i, i) + } + mVal := reflect.ValueOf(m) + v := reflect.ValueOf(i) + for _, keyVal := range v.MapKeys() { + val, err := ToInt64E(v.MapIndex(keyVal).Interface()) + if err != nil { + return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int64", i, i) + } + mVal.SetMapIndex(keyVal, reflect.ValueOf(val)) + } + return m, nil +} + // ToSliceE casts an interface to a []interface{} type. func ToSliceE(i interface{}) ([]interface{}, error) { var s []interface{} From 97e58d71a37339b87d4e006e51faa8ad65d398fb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B8rn=20Erik=20Pedersen?= Date: Wed, 24 Oct 2018 20:02:32 +0200 Subject: [PATCH 6/8] Update Travis config --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 4da9766..5a2b955 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,8 +1,8 @@ language: go sudo: required go: - - 1.7.5 - - 1.8 + - "1.10.x" + - "1.11.x" - tip os: - linux From 76b6d6c50002efe2e9f783d0d1c1050eb4c2c6f4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B8rn=20Erik=20Pedersen?= Date: Wed, 24 Oct 2018 20:03:41 +0200 Subject: [PATCH 7/8] Add go.mod --- go.mod | 1 + 1 file changed, 1 insertion(+) create mode 100644 go.mod diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..6313f39 --- /dev/null +++ b/go.mod @@ -0,0 +1 @@ +module github.com/spf13/cast From 8c9545af88b134710ab1cd196795e7f2388358d7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B8rn=20Erik=20Pedersen?= Date: Thu, 25 Oct 2018 00:49:29 +0200 Subject: [PATCH 8/8] Fix Travis build --- .travis.yml | 3 ++- cast_test.go | 2 +- caste.go | 6 +++--- go.mod | 6 ++++++ go.sum | 6 ++++++ 5 files changed, 18 insertions(+), 5 deletions(-) create mode 100644 go.sum diff --git a/.travis.yml b/.travis.yml index 5a2b955..6420d1c 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,7 +1,8 @@ language: go +env: + - GO111MODULE=on sudo: required go: - - "1.10.x" - "1.11.x" - tip os: diff --git a/cast_test.go b/cast_test.go index 1660ed0..d9a1479 100644 --- a/cast_test.go +++ b/cast_test.go @@ -872,7 +872,7 @@ func TestToStringMapInt64E(t *testing.T) { {map[string]int32{"v1": int32(33), "v2": int32(88)}, map[string]int64{"v1": 33, "v2": 88}, false}, {map[string]uint16{"v1": uint16(33), "v2": uint16(88)}, map[string]int64{"v1": 33, "v2": 88}, false}, {map[string]float64{"v1": float64(8.22), "v2": float64(43.32)}, map[string]int64{"v1": 8, "v2": 43}, false}, - {`{"v1": 67, "v2": 56}`, map[string]int64{"v1": 67, "v2": 56}, false}, + {`{"v1": 67, "v2": 56}`, map[string]int64{"v1": 67, "v2": 56}, false}, // errors {nil, nil, true}, diff --git a/caste.go b/caste.go index 81623c6..a4859fb 100644 --- a/caste.go +++ b/caste.go @@ -991,7 +991,7 @@ func ToStringMapE(i interface{}) (map[string]interface{}, error) { } // ToStringMapIntE casts an interface to a map[string]int{} type. -func ToStringMapIntE(i interface{}) (map[string]int, error) { +func ToStringMapIntE(i interface{}) (map[string]int, error) { var m = map[string]int{} if i == nil { return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int", i, i) @@ -1032,7 +1032,7 @@ func ToStringMapIntE(i interface{}) (map[string]int, error) { } // ToStringMapInt64E casts an interface to a map[string]int64{} type. -func ToStringMapInt64E(i interface{}) (map[string]int64, error) { +func ToStringMapInt64E(i interface{}) (map[string]int64, error) { var m = map[string]int64{} if i == nil { return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int64", i, i) @@ -1222,7 +1222,7 @@ func StringToDate(s string) (time.Time, error) { "2006-01-02 15:04:05 -07:00", "2006-01-02 15:04:05 -0700", "2006-01-02 15:04:05Z07:00", // RFC3339 without T - "2006-01-02 15:04:05Z0700", // RFC3339 without T or timezone hh:mm colon + "2006-01-02 15:04:05Z0700", // RFC3339 without T or timezone hh:mm colon "2006-01-02 15:04:05", time.Kitchen, time.Stamp, diff --git a/go.mod b/go.mod index 6313f39..c1c0232 100644 --- a/go.mod +++ b/go.mod @@ -1 +1,7 @@ module github.com/spf13/cast + +require ( + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/stretchr/testify v1.2.2 +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..e03ee77 --- /dev/null +++ b/go.sum @@ -0,0 +1,6 @@ +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=