From 9ce37a02f1bd3de4f7acea9a79432aabb582a8d6 Mon Sep 17 00:00:00 2001 From: Leo Rudberg Date: Mon, 2 Oct 2017 15:43:02 -0400 Subject: [PATCH] Added testing for Get when typeByDefValue is set. - viper_test.go: Added test for specifically testing type casts in Get when `typeByDefValue` is set. - viper.go: Removed (now stale) TODO for @bep. - LICENSE: Updated copyright to "The Viper Authors" as @spf13 requested. Also added Google as @google requested. --- LICENSE | 4 +- viper.go | 1 - viper_test.go | 127 ++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 129 insertions(+), 3 deletions(-) diff --git a/LICENSE b/LICENSE index 4527efb..132b6e1 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ The MIT License (MIT) -Copyright (c) 2014 Steve Francia +Copyright (c) 2014 The Viper Authors: Steve Francia, Google Inc., et al. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal @@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. \ No newline at end of file +SOFTWARE. diff --git a/viper.go b/viper.go index 963861a..0b7dc52 100644 --- a/viper.go +++ b/viper.go @@ -597,7 +597,6 @@ func (v *Viper) Get(key string) interface{} { } if v.typeByDefValue { - // TODO(bep) this branch isn't covered by a single test. valType := val path := strings.Split(lcaseKey, v.keyDelim) defVal := v.searchMap(v.defaults, path) diff --git a/viper_test.go b/viper_test.go index 774ca11..9fcad92 100644 --- a/viper_test.go +++ b/viper_test.go @@ -10,6 +10,7 @@ import ( "fmt" "io" "io/ioutil" + "math" "os" "path" "reflect" @@ -1169,6 +1170,132 @@ func TestParseNested(t *testing.T) { assert.Equal(t, 200*time.Millisecond, items[0].Nested.Delay) } +func TestGetTypeByDefValue(t *testing.T) { + const dobString = "1979-05-27T07:32:00Z" + dob, _ := time.Parse(time.RFC3339, dobString) + + for _, tc := range []struct { + name string // name of the test case + key string // key for the value + // First test that Getting the default value is what we expect it to be. + defaultProvide interface{} // the given default value + defaultWant interface{} // what we expect Getting that default will return + // Then set the OS environment to a different value with its type + // inferred from the default value. + envProvide string // the given string representation of the env value + envWant interface{} // what we expect Getting that env will return + }{{ + name: "casting to bool", + key: "bool_key", + defaultProvide: true, + defaultWant: true, + envProvide: "false", + envWant: false, + }, { + name: "casting to string", + key: "string_key", + defaultProvide: "reticulating splines", + defaultWant: "reticulating splines", + envProvide: "gophers!", + envWant: "gophers!", + }, { + name: "casting to int64", + key: "int64_key", + defaultProvide: int64(0xCAFE), + defaultWant: int(0xCAFE), + envProvide: "0xF00D", + envWant: int(0xF00D), + }, { + name: "casting to int32", + key: "int32_key", + defaultProvide: int32(0xD00D), + defaultWant: int(0xD00D), + envProvide: "0xBABE", + envWant: int(0xBABE), + }, { + name: "casting to int16", + key: "int16_key", + defaultProvide: int16(0xA), + defaultWant: int(0xA), + envProvide: "0xB", + envWant: int(0xB), + }, { + name: "casting to int8", + key: "int8_key", + defaultProvide: int8(4), + defaultWant: int(4), + envProvide: "3", + envWant: int(3), + }, { + name: "casting to int", + key: "int_key", + defaultProvide: int(0xCAFEF00D), + defaultWant: int(0xCAFEF00D), + envProvide: "5678", + envWant: int(5678), + }, { + name: "casting to float64", + key: "float64_key", + defaultProvide: float64(math.Pi), + defaultWant: float64(math.Pi), + envProvide: "98.7650", + envWant: float64(98.7650), + }, { + name: "casting to float32", + key: "float32_key", + // First truncate, then cast to 64 bits to get proper equality. + defaultProvide: float32(math.Phi), + defaultWant: float64(float32(math.Phi)), + envProvide: "1.23450", + envWant: float64(1.23450), + }, { + name: "casting to time", + key: "time_key", + defaultProvide: time.Unix(1234567890, 314159), + defaultWant: time.Unix(1234567890, 314159), + envProvide: dobString, + envWant: dob, + }, { + name: "casting to duration", + key: "duration_key", + defaultProvide: time.Duration(42 * time.Minute), + defaultWant: time.Duration(42 * time.Minute), + envProvide: "3h4m5s", + envWant: time.Duration(3*time.Hour + 4*time.Minute + 5*time.Second), + }, { + name: "casting to string slice", + key: "string_slice_key", + defaultProvide: []string{"hello", "world"}, + defaultWant: []string{"hello", "world"}, + envProvide: "aloha mars", + envWant: []string{"aloha", "mars"}, + }} { + t.Run(tc.name, func(t *testing.T) { + // Setup. + viper := New() + viper.SetTypeByDefaultValue(true) + viper.SetDefault(tc.key, tc.defaultProvide) + viper.AutomaticEnv() + + // Test default. + gotDefaultValue := viper.Get(tc.key) + assert.IsType(t, tc.defaultWant, gotDefaultValue, "when setting a default value") + assert.Equal(t, tc.defaultWant, gotDefaultValue, "when setting a default value") + + // Test env (supercedes default, exemplifies type cast). + if err := os.Setenv(strings.ToUpper(tc.key), tc.envProvide); err != nil { + t.Fatalf("Setenv unexpectedly failed: %v", err) + } + viper.BindEnv(tc.key) + gotEnvValue := viper.Get(tc.key) + assert.IsType(t, tc.envWant, gotEnvValue, "when setting a env value") + assert.Equal(t, tc.envWant, gotEnvValue, "when setting an env value") + + assert.IsType(t, gotDefaultValue, gotEnvValue) // sanity check + }) + } +} + func doTestCaseInsensitive(t *testing.T, typ, config string) { initConfig(typ, config) Set("RfD", true)