From b1b6c1d5596120d1d1278ffb832aa512c912d79a Mon Sep 17 00:00:00 2001 From: Gustavo Bazan Date: Sun, 15 Dec 2019 17:01:20 +0000 Subject: [PATCH 1/4] Add support to save file with no extension The suppport introduced for files with no file extension is only partial as trying to save the config file would fail with ` equires valid extensio` This adds support to saving such files --- viper.go | 15 ++++-- viper_test.go | 143 ++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 154 insertions(+), 4 deletions(-) diff --git a/viper.go b/viper.go index eb2f5177a..2c7f42fb7 100644 --- a/viper.go +++ b/viper.go @@ -1418,11 +1418,18 @@ func (v *Viper) SafeWriteConfigAs(filename string) error { func (v *Viper) writeConfig(filename string, force bool) error { jww.INFO.Println("Attempting to write configuration to file.") - ext := filepath.Ext(filename) - if len(ext) <= 1 { - return fmt.Errorf("filename: %s requires valid extension", filename) + var configType string + + if v.configType != "" { + configType = v.configType + } else { + ext := filepath.Ext(filename) + if len(ext) <= 1 { + return fmt.Errorf("filename: %s requires valid extension", filename) + } + configType = ext[1:] } - configType := ext[1:] + if !stringInSlice(configType, SupportedExts) { return UnsupportedConfigError(configType) } diff --git a/viper_test.go b/viper_test.go index fcd1b0e33..37d2f9987 100644 --- a/viper_test.go +++ b/viper_test.go @@ -1281,6 +1281,26 @@ func TestWriteConfigHCL(t *testing.T) { assert.Equal(t, hclWriteExpected, read) } +func TestWriteConfigHCLWithoutFileExtension(t *testing.T) { + v := New() + fs := afero.NewMemMapFs() + v.SetFs(fs) + v.SetConfigName("c") + v.SetConfigType("hcl") + err := v.ReadConfig(bytes.NewBuffer(hclExample)) + if err != nil { + t.Fatal(err) + } + if err := v.WriteConfigAs("c"); err != nil { + t.Fatal(err) + } + read, err := afero.ReadFile(fs, "c") + if err != nil { + t.Fatal(err) + } + assert.Equal(t, hclWriteExpected, read) +} + var jsonWriteExpected = []byte(`{ "batters": { "batter": [ @@ -1324,6 +1344,26 @@ func TestWriteConfigJson(t *testing.T) { assert.Equal(t, jsonWriteExpected, read) } +func TestWriteConfigJsonWithoutFileExtension(t *testing.T) { + v := New() + fs := afero.NewMemMapFs() + v.SetFs(fs) + v.SetConfigName("c") + v.SetConfigType("json") + err := v.ReadConfig(bytes.NewBuffer(jsonExample)) + if err != nil { + t.Fatal(err) + } + if err := v.WriteConfigAs("c"); err != nil { + t.Fatal(err) + } + read, err := afero.ReadFile(fs, "c") + if err != nil { + t.Fatal(err) + } + assert.Equal(t, jsonWriteExpected, read) +} + var propertiesWriteExpected = []byte(`p_id = 0001 p_type = donut p_name = Cake @@ -1351,6 +1391,26 @@ func TestWriteConfigProperties(t *testing.T) { assert.Equal(t, propertiesWriteExpected, read) } +func TestWriteConfigPropertiesWithoutFileExtension(t *testing.T) { + v := New() + fs := afero.NewMemMapFs() + v.SetFs(fs) + v.SetConfigName("c") + v.SetConfigType("properties") + err := v.ReadConfig(bytes.NewBuffer(propertiesExample)) + if err != nil { + t.Fatal(err) + } + if err := v.WriteConfigAs("c.properties"); err != nil { + t.Fatal(err) + } + read, err := afero.ReadFile(fs, "c.properties") + if err != nil { + t.Fatal(err) + } + assert.Equal(t, propertiesWriteExpected, read) +} + func TestWriteConfigTOML(t *testing.T) { fs := afero.NewMemMapFs() v := New() @@ -1383,6 +1443,38 @@ func TestWriteConfigTOML(t *testing.T) { assert.Equal(t, v.GetString("owner.organization"), v2.GetString("owner.organization")) } +func TestWriteConfigTOMLWithoutFileExtension(t *testing.T) { + fs := afero.NewMemMapFs() + v := New() + v.SetFs(fs) + v.SetConfigName("c") + v.SetConfigType("toml") + err := v.ReadConfig(bytes.NewBuffer(tomlExample)) + if err != nil { + t.Fatal(err) + } + if err := v.WriteConfigAs("c"); err != nil { + t.Fatal(err) + } + + // The TOML String method does not order the contents. + // Therefore, we must read the generated file and compare the data. + v2 := New() + v2.SetFs(fs) + v2.SetConfigName("c") + v2.SetConfigType("toml") + v2.SetConfigFile("c") + err = v2.ReadInConfig() + if err != nil { + t.Fatal(err) + } + + assert.Equal(t, v.GetString("title"), v2.GetString("title")) + assert.Equal(t, v.GetString("owner.bio"), v2.GetString("owner.bio")) + assert.Equal(t, v.GetString("owner.dob"), v2.GetString("owner.dob")) + assert.Equal(t, v.GetString("owner.organization"), v2.GetString("owner.organization")) +} + var dotenvWriteExpected = []byte(` TITLE="DotEnv Write Example" NAME=Oreo @@ -1420,6 +1512,37 @@ func TestWriteConfigDotEnv(t *testing.T) { assert.Equal(t, v.GetString("kind"), v2.GetString("kind")) } +func TestWriteConfigDotEnvWithoutFileExtension(t *testing.T) { + fs := afero.NewMemMapFs() + v := New() + v.SetFs(fs) + v.SetConfigName("c") + v.SetConfigType("env") + err := v.ReadConfig(bytes.NewBuffer(dotenvWriteExpected)) + if err != nil { + t.Fatal(err) + } + if err := v.WriteConfigAs("c"); err != nil { + t.Fatal(err) + } + + // The TOML String method does not order the contents. + // Therefore, we must read the generated file and compare the data. + v2 := New() + v2.SetFs(fs) + v2.SetConfigName("c") + v2.SetConfigType("env") + v2.SetConfigFile("c") + err = v2.ReadInConfig() + if err != nil { + t.Fatal(err) + } + + assert.Equal(t, v.GetString("title"), v2.GetString("title")) + assert.Equal(t, v.GetString("type"), v2.GetString("type")) + assert.Equal(t, v.GetString("kind"), v2.GetString("kind")) +} + var yamlWriteExpected = []byte(`age: 35 beard: true clothing: @@ -1456,6 +1579,26 @@ func TestWriteConfigYAML(t *testing.T) { assert.Equal(t, yamlWriteExpected, read) } +func TestWriteConfigYAMLWithoutFileExtension(t *testing.T) { + v := New() + fs := afero.NewMemMapFs() + v.SetFs(fs) + v.SetConfigName("c") + v.SetConfigType("yaml") + err := v.ReadConfig(bytes.NewBuffer(yamlExample)) + if err != nil { + t.Fatal(err) + } + if err := v.WriteConfigAs("c"); err != nil { + t.Fatal(err) + } + read, err := afero.ReadFile(fs, "c") + if err != nil { + t.Fatal(err) + } + assert.Equal(t, yamlWriteExpected, read) +} + func TestSafeWriteConfig(t *testing.T) { v := New() fs := afero.NewMemMapFs() From cc8e02114fa56213c2511e3e5e6240d24d6ced86 Mon Sep 17 00:00:00 2001 From: Gustavo Bazan Date: Sun, 15 Dec 2019 19:45:10 +0000 Subject: [PATCH 2/4] Update viper_test.go --- viper_test.go | 415 +++++++++++++++++++++----------------------------- 1 file changed, 174 insertions(+), 241 deletions(-) diff --git a/viper_test.go b/viper_test.go index 37d2f9987..429203d98 100644 --- a/viper_test.go +++ b/viper_test.go @@ -1324,46 +1324,6 @@ var jsonWriteExpected = []byte(`{ "type": "donut" }`) -func TestWriteConfigJson(t *testing.T) { - v := New() - fs := afero.NewMemMapFs() - v.SetFs(fs) - v.SetConfigName("c") - v.SetConfigType("json") - err := v.ReadConfig(bytes.NewBuffer(jsonExample)) - if err != nil { - t.Fatal(err) - } - if err := v.WriteConfigAs("c.json"); err != nil { - t.Fatal(err) - } - read, err := afero.ReadFile(fs, "c.json") - if err != nil { - t.Fatal(err) - } - assert.Equal(t, jsonWriteExpected, read) -} - -func TestWriteConfigJsonWithoutFileExtension(t *testing.T) { - v := New() - fs := afero.NewMemMapFs() - v.SetFs(fs) - v.SetConfigName("c") - v.SetConfigType("json") - err := v.ReadConfig(bytes.NewBuffer(jsonExample)) - if err != nil { - t.Fatal(err) - } - if err := v.WriteConfigAs("c"); err != nil { - t.Fatal(err) - } - read, err := afero.ReadFile(fs, "c") - if err != nil { - t.Fatal(err) - } - assert.Equal(t, jsonWriteExpected, read) -} - var propertiesWriteExpected = []byte(`p_id = 0001 p_type = donut p_name = Cake @@ -1371,178 +1331,6 @@ p_ppu = 0.55 p_batters.batter.type = Regular `) -func TestWriteConfigProperties(t *testing.T) { - v := New() - fs := afero.NewMemMapFs() - v.SetFs(fs) - v.SetConfigName("c") - v.SetConfigType("properties") - err := v.ReadConfig(bytes.NewBuffer(propertiesExample)) - if err != nil { - t.Fatal(err) - } - if err := v.WriteConfigAs("c.properties"); err != nil { - t.Fatal(err) - } - read, err := afero.ReadFile(fs, "c.properties") - if err != nil { - t.Fatal(err) - } - assert.Equal(t, propertiesWriteExpected, read) -} - -func TestWriteConfigPropertiesWithoutFileExtension(t *testing.T) { - v := New() - fs := afero.NewMemMapFs() - v.SetFs(fs) - v.SetConfigName("c") - v.SetConfigType("properties") - err := v.ReadConfig(bytes.NewBuffer(propertiesExample)) - if err != nil { - t.Fatal(err) - } - if err := v.WriteConfigAs("c.properties"); err != nil { - t.Fatal(err) - } - read, err := afero.ReadFile(fs, "c.properties") - if err != nil { - t.Fatal(err) - } - assert.Equal(t, propertiesWriteExpected, read) -} - -func TestWriteConfigTOML(t *testing.T) { - fs := afero.NewMemMapFs() - v := New() - v.SetFs(fs) - v.SetConfigName("c") - v.SetConfigType("toml") - err := v.ReadConfig(bytes.NewBuffer(tomlExample)) - if err != nil { - t.Fatal(err) - } - if err := v.WriteConfigAs("c.toml"); err != nil { - t.Fatal(err) - } - - // The TOML String method does not order the contents. - // Therefore, we must read the generated file and compare the data. - v2 := New() - v2.SetFs(fs) - v2.SetConfigName("c") - v2.SetConfigType("toml") - v2.SetConfigFile("c.toml") - err = v2.ReadInConfig() - if err != nil { - t.Fatal(err) - } - - assert.Equal(t, v.GetString("title"), v2.GetString("title")) - assert.Equal(t, v.GetString("owner.bio"), v2.GetString("owner.bio")) - assert.Equal(t, v.GetString("owner.dob"), v2.GetString("owner.dob")) - assert.Equal(t, v.GetString("owner.organization"), v2.GetString("owner.organization")) -} - -func TestWriteConfigTOMLWithoutFileExtension(t *testing.T) { - fs := afero.NewMemMapFs() - v := New() - v.SetFs(fs) - v.SetConfigName("c") - v.SetConfigType("toml") - err := v.ReadConfig(bytes.NewBuffer(tomlExample)) - if err != nil { - t.Fatal(err) - } - if err := v.WriteConfigAs("c"); err != nil { - t.Fatal(err) - } - - // The TOML String method does not order the contents. - // Therefore, we must read the generated file and compare the data. - v2 := New() - v2.SetFs(fs) - v2.SetConfigName("c") - v2.SetConfigType("toml") - v2.SetConfigFile("c") - err = v2.ReadInConfig() - if err != nil { - t.Fatal(err) - } - - assert.Equal(t, v.GetString("title"), v2.GetString("title")) - assert.Equal(t, v.GetString("owner.bio"), v2.GetString("owner.bio")) - assert.Equal(t, v.GetString("owner.dob"), v2.GetString("owner.dob")) - assert.Equal(t, v.GetString("owner.organization"), v2.GetString("owner.organization")) -} - -var dotenvWriteExpected = []byte(` -TITLE="DotEnv Write Example" -NAME=Oreo -KIND=Biscuit -`) - -func TestWriteConfigDotEnv(t *testing.T) { - fs := afero.NewMemMapFs() - v := New() - v.SetFs(fs) - v.SetConfigName("c") - v.SetConfigType("env") - err := v.ReadConfig(bytes.NewBuffer(dotenvWriteExpected)) - if err != nil { - t.Fatal(err) - } - if err := v.WriteConfigAs("c.env"); err != nil { - t.Fatal(err) - } - - // The TOML String method does not order the contents. - // Therefore, we must read the generated file and compare the data. - v2 := New() - v2.SetFs(fs) - v2.SetConfigName("c") - v2.SetConfigType("env") - v2.SetConfigFile("c.env") - err = v2.ReadInConfig() - if err != nil { - t.Fatal(err) - } - - assert.Equal(t, v.GetString("title"), v2.GetString("title")) - assert.Equal(t, v.GetString("type"), v2.GetString("type")) - assert.Equal(t, v.GetString("kind"), v2.GetString("kind")) -} - -func TestWriteConfigDotEnvWithoutFileExtension(t *testing.T) { - fs := afero.NewMemMapFs() - v := New() - v.SetFs(fs) - v.SetConfigName("c") - v.SetConfigType("env") - err := v.ReadConfig(bytes.NewBuffer(dotenvWriteExpected)) - if err != nil { - t.Fatal(err) - } - if err := v.WriteConfigAs("c"); err != nil { - t.Fatal(err) - } - - // The TOML String method does not order the contents. - // Therefore, we must read the generated file and compare the data. - v2 := New() - v2.SetFs(fs) - v2.SetConfigName("c") - v2.SetConfigType("env") - v2.SetConfigFile("c") - err = v2.ReadInConfig() - if err != nil { - t.Fatal(err) - } - - assert.Equal(t, v.GetString("title"), v2.GetString("title")) - assert.Equal(t, v.GetString("type"), v2.GetString("type")) - assert.Equal(t, v.GetString("kind"), v2.GetString("kind")) -} - var yamlWriteExpected = []byte(`age: 35 beard: true clothing: @@ -1559,44 +1347,189 @@ hobbies: name: steve `) -func TestWriteConfigYAML(t *testing.T) { - v := New() +func TestWriteConfig(t *testing.T) { fs := afero.NewMemMapFs() - v.SetFs(fs) - v.SetConfigName("c") - v.SetConfigType("yaml") - err := v.ReadConfig(bytes.NewBuffer(yamlExample)) - if err != nil { - t.Fatal(err) - } - if err := v.WriteConfigAs("c.yaml"); err != nil { - t.Fatal(err) + testCases := map[string]struct { + configName string + configType string + fileName string + input []byte + expectedContent []byte + }{ + "json with file extension": { + configName: "c", + configType: "json", + fileName: "c.json", + input: jsonExample, + expectedContent: jsonWriteExpected, + }, + "json without file extension": { + configName: "c", + configType: "json", + fileName: "c", + input: jsonExample, + expectedContent: jsonWriteExpected, + }, + "properties with file extension": { + configName: "c", + configType: "properties", + fileName: "c.properties", + input: propertiesExample, + expectedContent: propertiesWriteExpected, + }, + "properties without file extension": { + configName: "c", + configType: "properties", + fileName: "c", + input: propertiesExample, + expectedContent: propertiesWriteExpected, + }, + "yaml with file extension": { + configName: "c", + configType: "yaml", + fileName: "c.yaml", + input: yamlExample, + expectedContent: yamlWriteExpected, + }, + "yaml without file extension": { + configName: "c", + configType: "yaml", + fileName: "c", + input: yamlExample, + expectedContent: yamlWriteExpected, + }, } - read, err := afero.ReadFile(fs, "c.yaml") - if err != nil { - t.Fatal(err) + for name, tc := range testCases { + t.Run(name, func(t *testing.T) { + v := New() + v.SetFs(fs) + v.SetConfigName(tc.fileName) + v.SetConfigType(tc.configType) + + err := v.ReadConfig(bytes.NewBuffer(tc.input)) + if err != nil { + t.Fatal(err) + } + if err := v.WriteConfigAs(tc.fileName); err != nil { + t.Fatal(err) + } + read, err := afero.ReadFile(fs, tc.fileName) + if err != nil { + t.Fatal(err) + } + assert.Equal(t, tc.expectedContent, read) + }) } - assert.Equal(t, yamlWriteExpected, read) } -func TestWriteConfigYAMLWithoutFileExtension(t *testing.T) { - v := New() +func TestWriteConfigTOML(t *testing.T) { fs := afero.NewMemMapFs() - v.SetFs(fs) - v.SetConfigName("c") - v.SetConfigType("yaml") - err := v.ReadConfig(bytes.NewBuffer(yamlExample)) - if err != nil { - t.Fatal(err) + + testCases := map[string]struct { + configName string + configType string + fileName string + input []byte + }{ + "with file extension": { + configName: "c", + configType: "toml", + fileName: "c.toml", + input: tomlExample, + }, + "without file extension": { + configName: "c", + configType: "toml", + fileName: "c", + input: tomlExample, + }, } - if err := v.WriteConfigAs("c"); err != nil { - t.Fatal(err) + for name, tc := range testCases { + t.Run(name, func(t *testing.T) { + v := New() + v.SetFs(fs) + v.SetConfigName(tc.configName) + v.SetConfigType(tc.configType) + err := v.ReadConfig(bytes.NewBuffer(tc.input)) + if err != nil { + t.Fatal(err) + } + if err := v.WriteConfigAs(tc.fileName); err != nil { + t.Fatal(err) + } + + // The TOML String method does not order the contents. + // Therefore, we must read the generated file and compare the data. + v2 := New() + v2.SetFs(fs) + v2.SetConfigName(tc.configName) + v2.SetConfigType(tc.configType) + v2.SetConfigFile(tc.fileName) + err = v2.ReadInConfig() + if err != nil { + t.Fatal(err) + } + + assert.Equal(t, v.GetString("title"), v2.GetString("title")) + assert.Equal(t, v.GetString("owner.bio"), v2.GetString("owner.bio")) + assert.Equal(t, v.GetString("owner.dob"), v2.GetString("owner.dob")) + assert.Equal(t, v.GetString("owner.organization"), v2.GetString("owner.organization")) + }) } - read, err := afero.ReadFile(fs, "c") - if err != nil { - t.Fatal(err) +} + +func TestWriteConfigDotEnv(t *testing.T) { + fs := afero.NewMemMapFs() + testCases := map[string]struct { + configName string + configType string + fileName string + input []byte + }{ + "with file extension": { + configName: "c", + configType: "env", + fileName: "c.env", + input: dotenvExample, + }, + "without file extension": { + configName: "c", + configType: "env", + fileName: "c", + input: dotenvExample, + }, + } + for name, tc := range testCases { + t.Run(name, func(t *testing.T) { + v := New() + v.SetFs(fs) + v.SetConfigName(tc.configName) + v.SetConfigType(tc.configType) + err := v.ReadConfig(bytes.NewBuffer(tc.input)) + if err != nil { + t.Fatal(err) + } + if err := v.WriteConfigAs(tc.fileName); err != nil { + t.Fatal(err) + } + + // The TOML String method does not order the contents. + // Therefore, we must read the generated file and compare the data. + v2 := New() + v2.SetFs(fs) + v2.SetConfigName(tc.configName) + v2.SetConfigType(tc.configType) + v2.SetConfigFile(tc.fileName) + err = v2.ReadInConfig() + if err != nil { + t.Fatal(err) + } + + assert.Equal(t, v.GetString("title_dotenv"), v2.GetString("title_dotenv")) + assert.Equal(t, v.GetString("type_dotenv"), v2.GetString("type_dotenv")) + assert.Equal(t, v.GetString("kind_dotenv"), v2.GetString("kind_dotenv")) + }) } - assert.Equal(t, yamlWriteExpected, read) } func TestSafeWriteConfig(t *testing.T) { From 8f40d15c5605ef83a6c73a33af90b468c0c4df7a Mon Sep 17 00:00:00 2001 From: Gustavo Bazan Date: Sun, 15 Dec 2019 19:48:06 +0000 Subject: [PATCH 3/4] Update viper_test.go --- viper_test.go | 54 +++++++++++++-------------------------------------- 1 file changed, 14 insertions(+), 40 deletions(-) diff --git a/viper_test.go b/viper_test.go index 429203d98..4d35923c1 100644 --- a/viper_test.go +++ b/viper_test.go @@ -1261,46 +1261,6 @@ var hclWriteExpected = []byte(`"foos" = { "type" = "donut"`) -func TestWriteConfigHCL(t *testing.T) { - v := New() - fs := afero.NewMemMapFs() - v.SetFs(fs) - v.SetConfigName("c") - v.SetConfigType("hcl") - err := v.ReadConfig(bytes.NewBuffer(hclExample)) - if err != nil { - t.Fatal(err) - } - if err := v.WriteConfigAs("c.hcl"); err != nil { - t.Fatal(err) - } - read, err := afero.ReadFile(fs, "c.hcl") - if err != nil { - t.Fatal(err) - } - assert.Equal(t, hclWriteExpected, read) -} - -func TestWriteConfigHCLWithoutFileExtension(t *testing.T) { - v := New() - fs := afero.NewMemMapFs() - v.SetFs(fs) - v.SetConfigName("c") - v.SetConfigType("hcl") - err := v.ReadConfig(bytes.NewBuffer(hclExample)) - if err != nil { - t.Fatal(err) - } - if err := v.WriteConfigAs("c"); err != nil { - t.Fatal(err) - } - read, err := afero.ReadFile(fs, "c") - if err != nil { - t.Fatal(err) - } - assert.Equal(t, hclWriteExpected, read) -} - var jsonWriteExpected = []byte(`{ "batters": { "batter": [ @@ -1356,6 +1316,20 @@ func TestWriteConfig(t *testing.T) { input []byte expectedContent []byte }{ + "hcl with file extension": { + configName: "c", + configType: "hcl", + fileName: "c.hcl", + input: hclExample, + expectedContent: hclWriteExpected, + }, + "hcl without file extension": { + configName: "c", + configType: "hcl", + fileName: "c", + input: hclExample, + expectedContent: hclWriteExpected, + }, "json with file extension": { configName: "c", configType: "json", From 717d682741fa3aeb6d3ce1a670e60b3908e71444 Mon Sep 17 00:00:00 2001 From: Gustavo Bazan Date: Fri, 10 Jan 2020 15:35:19 +0000 Subject: [PATCH 4/4] PR comments --- viper.go | 14 ++++++------- viper_test.go | 54 +++++++++++++++++++++++++++++++++++++++++---------- 2 files changed, 51 insertions(+), 17 deletions(-) diff --git a/viper.go b/viper.go index 2c7f42fb7..e10f23948 100644 --- a/viper.go +++ b/viper.go @@ -1420,14 +1420,14 @@ func (v *Viper) writeConfig(filename string, force bool) error { jww.INFO.Println("Attempting to write configuration to file.") var configType string - if v.configType != "" { - configType = v.configType - } else { - ext := filepath.Ext(filename) - if len(ext) <= 1 { - return fmt.Errorf("filename: %s requires valid extension", filename) - } + ext := filepath.Ext(filename) + if ext != "" { configType = ext[1:] + } else { + configType = v.configType + } + if configType == "" { + return fmt.Errorf("config type could not be determined for %s", filename) } if !stringInSlice(configType, SupportedExts) { diff --git a/viper_test.go b/viper_test.go index 4d35923c1..6c9a84a94 100644 --- a/viper_test.go +++ b/viper_test.go @@ -1311,79 +1311,113 @@ func TestWriteConfig(t *testing.T) { fs := afero.NewMemMapFs() testCases := map[string]struct { configName string - configType string + inConfigType string + outConfigType string fileName string input []byte expectedContent []byte }{ "hcl with file extension": { configName: "c", - configType: "hcl", + inConfigType: "hcl", + outConfigType: "hcl", fileName: "c.hcl", input: hclExample, expectedContent: hclWriteExpected, }, "hcl without file extension": { configName: "c", - configType: "hcl", + inConfigType: "hcl", + outConfigType: "hcl", fileName: "c", input: hclExample, expectedContent: hclWriteExpected, }, + "hcl with file extension and mismatch type": { + configName: "c", + inConfigType: "hcl", + outConfigType: "json", + fileName: "c.hcl", + input: hclExample, + expectedContent: hclWriteExpected, + }, "json with file extension": { configName: "c", - configType: "json", + inConfigType: "json", + outConfigType: "json", fileName: "c.json", input: jsonExample, expectedContent: jsonWriteExpected, }, "json without file extension": { configName: "c", - configType: "json", + inConfigType: "json", + outConfigType: "json", fileName: "c", input: jsonExample, expectedContent: jsonWriteExpected, }, + "json with file extension and mismatch type": { + configName: "c", + inConfigType: "json", + outConfigType: "hcl", + fileName: "c.json", + input: jsonExample, + expectedContent: jsonWriteExpected, + }, "properties with file extension": { configName: "c", - configType: "properties", + inConfigType: "properties", + outConfigType: "properties", fileName: "c.properties", input: propertiesExample, expectedContent: propertiesWriteExpected, }, "properties without file extension": { configName: "c", - configType: "properties", + inConfigType: "properties", + outConfigType: "properties", fileName: "c", input: propertiesExample, expectedContent: propertiesWriteExpected, }, "yaml with file extension": { configName: "c", - configType: "yaml", + inConfigType: "yaml", + outConfigType: "yaml", fileName: "c.yaml", input: yamlExample, expectedContent: yamlWriteExpected, }, "yaml without file extension": { configName: "c", - configType: "yaml", + inConfigType: "yaml", + outConfigType: "yaml", fileName: "c", input: yamlExample, expectedContent: yamlWriteExpected, }, + "yaml with file extension and mismatch type": { + configName: "c", + inConfigType: "yaml", + outConfigType: "json", + fileName: "c.yaml", + input: yamlExample, + expectedContent: yamlWriteExpected, + }, } for name, tc := range testCases { t.Run(name, func(t *testing.T) { v := New() v.SetFs(fs) v.SetConfigName(tc.fileName) - v.SetConfigType(tc.configType) + v.SetConfigType(tc.inConfigType) err := v.ReadConfig(bytes.NewBuffer(tc.input)) if err != nil { t.Fatal(err) } + v.SetConfigType(tc.outConfigType) if err := v.WriteConfigAs(tc.fileName); err != nil { t.Fatal(err) }