.golangci.yml

@@ -577,7 +577,6 @@ linters-settings:
       # List of allowed modules.
       # Default: []
       modules:                                                        # List of allowed modules
-        - github.com/pelletier/go-toml/v2
         - github.com/stretchr/testify
         # - gopkg.in/yaml.v2
       # List of allowed module domains.

CHANGELOG.md

@@ -2,10 +2,6 @@
 
 ## Unreleased
 
-- Add support for TOML configuration files
-- Use stdlib for tests instead of convey
-- Update golangci-lint config
-
 ## v0.2.0 (2021-12-19)
 
 - Added License
@@ -13,5 +9,5 @@
 - Added a Loadfiles function to load at once several config files
 
 ## v0.1.0 (2020-03-17)
+- Initial varsion
 
-- Initial varsion with support for JSON files

adapters.go

@@ -1,86 +0,0 @@
-package conf
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-
-	"github.com/pelletier/go-toml/v2"
-)
-
-type filetype int
-
-const (
-	typeInvalid filetype = iota
-	typeJSON
-	typeTOML
-)
-
-func getType(filename string) filetype {
-	switch {
-	case strings.HasSuffix(filename, ".json"):
-		return typeJSON
-	case strings.HasSuffix(filename, ".toml"):
-		return typeTOML
-	default:
-		return typeInvalid
-	}
-}
-
-func unmarshal(ft filetype, data []byte, v interface{}) error {
-	switch ft {
-	case typeJSON:
-		return unmarshalJSON(data, v)
-	case typeTOML:
-		return unmarshalTOML(data, v)
-	default:
-		return ErrUnsupportedFileType
-	}
-}
-
-func marshal(ft filetype, v interface{}) ([]byte, error) {
-	switch ft {
-	case typeJSON:
-		return marshalJSON(v)
-	case typeTOML:
-		return marshalTOML(v)
-	default:
-		return nil, ErrUnsupportedFileType
-	}
-}
-
-func unmarshalJSON(data []byte, v interface{}) error {
-	err := json.Unmarshal(data, v)
-	if err != nil {
-		return fmt.Errorf("cannot parse config file: %w", err)
-	}
-
-	return nil
-}
-
-func marshalJSON(v interface{}) ([]byte, error) {
-	data, err := json.MarshalIndent(v, "", "  ")
-	if err != nil {
-		return nil, fmt.Errorf("cannot generate config content: %w", err)
-	}
-
-	return data, nil
-}
-
-func unmarshalTOML(data []byte, v interface{}) error {
-	err := toml.Unmarshal(data, v)
-	if err != nil {
-		return fmt.Errorf("cannot parse config file: %w", err)
-	}
-
-	return nil
-}
-
-func marshalTOML(v interface{}) ([]byte, error) {
-	data, err := toml.Marshal(v)
-	if err != nil {
-		return nil, fmt.Errorf("cannot generate config content: %w", err)
-	}
-
-	return data, nil
-}

config.go

@@ -1,25 +1,15 @@
-// Package conf defines utils to simplify configuration management.
+// Package conf defines utils to simplify configuration
-//
+// management.
-// It provides functions to load and save config files.
-//
-// Several formats are supported. The encoders/decoders are selected according
-// to the extension of the paths passed to functions:
-//
-// - JSON: ".json"
-// - TOML: ".toml"
 package conf
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
 )
 
-// ErrUnsupportedFileType is returned when the type of the config file is not
-// supported.
-var ErrUnsupportedFileType = errors.New("unsupported config type")
-
 // LoadFile reads the file at path, parses its json content and fills the struct
 // with the content of the file.
 func LoadFile(path string, data interface{}) error {
@@ -31,7 +21,7 @@ func LoadFile(path string, data interface{}) error {
 // If a path does not exist, it is ignored.
 //
 // It returns an error only if the content of a file is invalid, i.e. it
-// cannot be unmarshaled to the struct.
+// cannot be unmarshaled by json.
 func LoadFiles(data interface{}, paths ...string) error {
 	for _, p := range paths {
 		err := read(p, data)
@@ -88,13 +78,18 @@ func read(path string, data interface{}) error {
 		return fmt.Errorf("cannot read config file: %w", err)
 	}
 
-	return unmarshal(getType(path), content, data)
+	err = json.Unmarshal(content, &data)
+	if err != nil {
+		return fmt.Errorf("cannot parse config file: %w", err)
+	}
+
+	return nil
 }
 
 func write(path string, data interface{}) error {
-	content, err := marshal(getType(path), data)
+	content, err := json.MarshalIndent(data, "", "  ")
 	if err != nil {
-		return err
+		return fmt.Errorf("cannot generate config content: %w", err)
 	}
 
 	err = os.WriteFile(path, content, 0o600)

config_test.go

@@ -11,68 +11,6 @@ import (
 	"code.bcarlin.xyz/go/conf"
 )
 
-func TestJSONFiles(t *testing.T) {
-	t.Parallel()
-
-	runTestSuite(t, "json")
-}
-
-func TestTOMLFiles(t *testing.T) {
-	t.Parallel()
-
-	runTestSuite(t, "toml")
-}
-
-func TestUnknownFiles(t *testing.T) {
-	t.Parallel()
-
-	t.Run("LoadFile", func(t *testing.T) {
-		t.Parallel()
-
-		s := struct{}{}
-
-		err := conf.LoadFile("test_data/valid.unknown", &s)
-		if assert.Error(t, err) {
-			assert.ErrorIs(t, err, conf.ErrUnsupportedFileType)
-		}
-	})
-
-	t.Run("SaveFile", func(t *testing.T) {
-		t.Parallel()
-
-		s := struct{}{}
-
-		err := conf.SaveFile("test.unknown", &s)
-		if assert.Error(t, err) {
-			assert.ErrorIs(t, err, conf.ErrUnsupportedFileType)
-		}
-
-		assert.NoFileExists(t, "test.unknown")
-	})
-
-	t.Run("LoadAndUpdateFile", func(t *testing.T) {
-		t.Parallel()
-
-		s := struct{}{}
-
-		err := conf.LoadAndUpdateFile("test.unknown", &s)
-		if assert.Error(t, err) {
-			assert.ErrorIs(t, err, conf.ErrUnsupportedFileType)
-		}
-
-		assert.NoFileExists(t, "test.unknown")
-	})
-}
-
-func runTestSuite(t *testing.T, ext string) {
-	t.Helper()
-
-	testLoadFile(t, ext)
-	testLoadFiles(t, ext)
-	testSaveFile(t, ext)
-	testLoadAndUpdateFile(t, ext)
-}
-
 type testconf struct {
 	inUpdate  func()
 	String    string
@@ -86,352 +24,374 @@ func (t testconf) Update() {
 	}
 }
 
-func testLoadFile(t *testing.T, ext string) {
+func TestLoadFile(t *testing.T) {
-	t.Helper()
+	t.Parallel()
 
-	t.Run("LoadFile", func(t *testing.T) {
+	t.Run("with a valid file", func(t *testing.T) {
 		t.Parallel()
 
-		t.Run("with a valid file", func(t *testing.T) {
+		c := testconf{
-			t.Parallel()
+			String:    "default string",
+			Int:       1,
+			Invariant: "should not change",
+		}
 
-			c := testconf{
+		file := "test_data/valid.json"
-				String:    "default string",
-				Int:       1,
-				Invariant: "should not change",
-			}
 
-			file := "test_data/valid." + ext
+		err := conf.LoadFile(file, &c)
+		require.NoError(t, err)
 
-			err := conf.LoadFile(file, &c)
+		assert.Equal(t, "config string", c.String)
-			require.NoError(t, err)
+		assert.Equal(t, 42, c.Int)
+		assert.Equal(t, "should not change", c.Invariant)
+	})
 
-			assert.Equal(t, "config string", c.String)
+	t.Run("with an invalid file", func(t *testing.T) {
-			assert.Equal(t, 42, c.Int)
+		t.Parallel()
-			assert.Equal(t, "should not change", c.Invariant)
-		})
 
-		t.Run("with an invalid file", func(t *testing.T) {
+		c := testconf{
-			t.Parallel()
+			String:    "default string",
+			Int:       1,
+			Invariant: "should not change",
+		}
 
-			c := testconf{
+		file := "test_data/invalid.json"
-				String:    "default string",
-				Int:       1,
-				Invariant: "should not change",
-			}
 
-			file := "test_data/invalid." + ext
+		err := conf.LoadFile(file, &c)
+		require.Error(t, err)
 
-			err := conf.LoadFile(file, &c)
+		assert.Equal(t, "default string", c.String)
-			require.Error(t, err)
+		assert.Equal(t, 1, c.Int)
+		assert.Equal(t, "should not change", c.Invariant)
+	})
 
-			assert.Equal(t, "default string", c.String)
+	t.Run("with a non existent file", func(t *testing.T) {
-			assert.Equal(t, 1, c.Int)
+		t.Parallel()
-			assert.Equal(t, "should not change", c.Invariant)
-		})
 
-		t.Run("with a non existent file", func(t *testing.T) {
+		c := testconf{
-			t.Parallel()
+			String:    "default string",
+			Int:       1,
+			Invariant: "should not change",
+		}
 
-			c := testconf{
+		file := "does-not-exist.conf"
-				String:    "default string",
-				Int:       1,
-				Invariant: "should not change",
-			}
 
-			file := "does-not-exist." + ext
+		err := conf.LoadFile(file, &c)
+		require.Error(t, err)
 
-			err := conf.LoadFile(file, &c)
+		assert.Equal(t, "default string", c.String)
-			require.Error(t, err)
+		assert.Equal(t, 1, c.Int)
-
+		assert.Equal(t, "should not change", c.Invariant)
-			assert.Equal(t, "default string", c.String)
-			assert.Equal(t, 1, c.Int)
-			assert.Equal(t, "should not change", c.Invariant)
-		})
 	})
 }
 
-func testLoadFiles(t *testing.T, ext string) {
+func TestLoadFiles(t *testing.T) {
-	t.Helper()
+	t.Parallel()
 
-	t.Run("LoadFiles", func(t *testing.T) {
+	t.Run("with two valid files with different options", func(t *testing.T) {
 		t.Parallel()
 
-		t.Run("with two valid files with different options", func(t *testing.T) {
+		c := testconf{}
-			t.Parallel()
+		tmpDir := t.TempDir()
 
-			c := testconf{}
+		content1 := []byte(`{"String": "foo"}`)
-			err := conf.LoadFiles(&c, "test_data/part1."+ext, "test_data/part2."+ext)
+		content2 := []byte(`{"Int": 42}`)
-			require.NoError(t, err)
+		paths := []string{
+			filepath.Join(tmpDir, "file1.json"),
+			filepath.Join(tmpDir, "file2.json"),
+		}
 
-			assert.Equal(t, "foo", c.String)
+		err := os.WriteFile(paths[0], content1, 0o600)
-			assert.Equal(t, 42, c.Int)
+		require.NoError(t, err)
-		})
+		err = os.WriteFile(paths[1], content2, 0o600)
+		require.NoError(t, err)
 
-		t.Run("with two valid files with the same option", func(t *testing.T) {
+		err = conf.LoadFiles(&c, paths...)
-			t.Parallel()
+		require.NoError(t, err)
 
-			c := testconf{}
+		assert.Equal(t, "foo", c.String)
+		assert.Equal(t, 42, c.Int)
+	})
 
-			err := conf.LoadFiles(&c, "test_data/same1."+ext, "test_data/same2."+ext)
+	t.Run("with two valid files with the same option", func(t *testing.T) {
-			require.NoError(t, err)
+		t.Parallel()
 
-			assert.Equal(t, "bar", c.String)
+		c := testconf{}
-		})
+		tmpDir := t.TempDir()
 
-		t.Run("with one non-existing and one existing file", func(t *testing.T) {
+		content1 := []byte(`{"String": "foo"}`)
-			t.Parallel()
+		content2 := []byte(`{"String": "bar"}`)
+		paths := []string{
+			filepath.Join(tmpDir, "file1.json"),
+			filepath.Join(tmpDir, "file2.json"),
+		}
 
-			c := testconf{}
+		err := os.WriteFile(paths[0], content1, 0o600)
+		require.NoError(t, err)
+		err = os.WriteFile(paths[1], content2, 0o600)
+		require.NoError(t, err)
 
-			err := conf.LoadFiles(&c, "does-not-exist."+ext, "test_data/valid."+ext)
+		err = conf.LoadFiles(&c, paths...)
-			require.NoError(t, err)
+		require.NoError(t, err)
 
-			assert.Equal(t, "config string", c.String)
+		assert.Equal(t, "bar", c.String)
-		})
+	})
 
-		t.Run("with one invalid and one valid file", func(t *testing.T) {
+	t.Run("with one non-existing and one existing file", func(t *testing.T) {
-			t.Parallel()
+		t.Parallel()
 
-			c := testconf{}
+		c := testconf{}
+		tmpDir := t.TempDir()
 
-			err := conf.LoadFiles(&c, "test_data/invalid."+ext, "test_data/valid."+ext)
+		content2 := []byte(`{"String": "bar"}`)
-			require.Error(t, err)
+		paths := []string{
+			"does-not-exist.json",
+			filepath.Join(tmpDir, "file2.json"),
+		}
 
-			assert.Equal(t, "", c.String)
+		err := os.WriteFile(paths[1], content2, 0o600)
-		})
+		require.NoError(t, err)
+
+		err = conf.LoadFiles(&c, paths...)
+		require.NoError(t, err)
+
+		assert.Equal(t, "bar", c.String)
+	})
+
+	t.Run("with one valid and one invalid file", func(t *testing.T) {
+		t.Parallel()
+
+		c := testconf{}
+		tmpDir := t.TempDir()
+
+		content1 := []byte(`{"`)
+		content2 := []byte(`{"String": "bar"}`)
+		paths := []string{
+			filepath.Join(tmpDir, "file1.json"),
+			filepath.Join(tmpDir, "file2.json"),
+		}
+
+		err := os.WriteFile(paths[0], content1, 0o600)
+		require.NoError(t, err)
+		err = os.WriteFile(paths[1], content2, 0o600)
+		require.NoError(t, err)
+
+		err = conf.LoadFiles(&c, paths...)
+		require.Error(t, err)
+
+		assert.Equal(t, "", c.String)
 	})
 }
 
-func testSaveFile(t *testing.T, ext string) {
+func TestSaveFile(t *testing.T) {
-	t.Helper()
+	t.Parallel()
 
-	t.Run("SaveFile", func(t *testing.T) {
+	t.Run("with a valid path", func(t *testing.T) {
 		t.Parallel()
 
-		t.Run("with a valid path", func(t *testing.T) {
+		c := testconf{
-			t.Parallel()
+			String:    "default string",
+			Invariant: "should not change",
+			Int:       1,
+		}
+		tmpDir := t.TempDir()
+		file := filepath.Join(tmpDir, "test.conf")
 
-			c := testconf{
+		err := conf.SaveFile(file, &c)
-				String:    "default string",
+		require.NoError(t, err)
-				Invariant: "should not change",
-				Int:       1,
-			}
-			tmpDir := t.TempDir()
-			file := filepath.Join(tmpDir, "test."+ext)
 
-			err := conf.SaveFile(file, &c)
+		assert.FileExists(t, file)
-			require.NoError(t, err)
 
-			require.FileExists(t, file)
+		expected := "{\n  \"String\": \"default string\",\n  \"Invariant\": \"should not change\",\n  \"Int\": 1\n}"
+		got, err := os.ReadFile(file)
+		require.NoError(t, err)
+		assert.Equal(t, expected, string(got))
+	})
 
-			expected, err := os.ReadFile("test_data/full." + ext)
+	t.Run("with a valid path and invalid data", func(t *testing.T) {
-			require.NoError(t, err)
+		t.Parallel()
-			got, err := os.ReadFile(file)
-			require.NoError(t, err)
 
-			assert.Equal(t, string(expected), string(got))
+		tmpDir := t.TempDir()
-		})
+		file := filepath.Join(tmpDir, "test.conf")
 
-		t.Run("with a valid path and invalid data", func(t *testing.T) {
+		err := conf.SaveFile(file, func() error { return nil })
-			t.Parallel()
+		require.Error(t, err)
 
-			tmpDir := t.TempDir()
+		assert.NoFileExists(t, file)
-			file := filepath.Join(tmpDir, "test."+ext)
+	})
 
-			err := conf.SaveFile(file, func() error { return nil })
+	t.Run("with an invalid path", func(t *testing.T) {
-			require.Error(t, err)
+		t.Parallel()
 
-			assert.NoFileExists(t, file)
+		c := testconf{
-		})
+			String:    "default string",
+			Invariant: "should not change",
+			Int:       1,
+		}
+		file := "cannot/write/here.conf"
 
-		t.Run("with an invalid path", func(t *testing.T) {
+		err := conf.SaveFile(file, &c)
-			t.Parallel()
+		require.Error(t, err)
 
-			c := testconf{
+		assert.NoFileExists(t, file)
-				String:    "default string",
-				Invariant: "should not change",
-				Int:       1,
-			}
-			file := "cannot/write/here." + ext
-
-			err := conf.SaveFile(file, &c)
-			require.Error(t, err)
-
-			assert.NoFileExists(t, file)
-		})
 	})
 }
 
-func testLoadAndUpdateFile(t *testing.T, ext string) {
+func TestLoadAndUpdateFile(t *testing.T) {
-	t.Helper()
+	t.Parallel()
 
-	t.Run("LoadAndUpdateFile", func(t *testing.T) {
+	t.Run("when the target file does not exist", func(t *testing.T) {
 		t.Parallel()
 
-		t.Run("when the target file does not exist", func(t *testing.T) {
+		updated := false
-			t.Parallel()
+		c := testconf{
+			String:    "default string",
+			Int:       1,
+			Invariant: "should not change",
+			inUpdate:  func() { updated = true },
+		}
+		tmpDir := t.TempDir()
+		file := filepath.Join(tmpDir, "test.conf")
 
-			updated := false
+		err := conf.LoadAndUpdateFile(file, &c)
-			c := testconf{
+		require.NoError(t, err)
-				String:    "default string",
-				Int:       1,
-				Invariant: "should not change",
-				inUpdate:  func() { updated = true },
-			}
-			tmpDir := t.TempDir()
-			file := filepath.Join(tmpDir, "does-not-exist."+ext)
 
-			err := conf.LoadAndUpdateFile(file, &c)
+		var c2 testconf
-			require.NoError(t, err)
+		err = conf.LoadFile(file, &c2)
+		require.NoError(t, err)
+		assert.Equal(t, c.String, c2.String)
+		assert.Equal(t, c.Int, c2.Int)
+		assert.Equal(t, c.Invariant, c2.Invariant)
 
-			require.FileExists(t, file)
+		assert.False(t, updated)
+	})
 
-			var c2 testconf
+	t.Run("when the path cannot be written", func(t *testing.T) {
-			err = conf.LoadFile(file, &c2)
+		t.Parallel()
-			require.NoError(t, err)
-			assert.Equal(t, c.String, c2.String)
-			assert.Equal(t, c.Int, c2.Int)
-			assert.Equal(t, c.Invariant, c2.Invariant)
 
-			assert.False(t, updated)
+		updated := false
-		})
+		c := testconf{
+			String:    "default string",
+			Int:       1,
+			Invariant: "should not change",
+			inUpdate:  func() { updated = true },
+		}
+		tmpDir := t.TempDir()
+		file := filepath.Join(tmpDir, "does-not-exist", "test.conf")
 
-		t.Run("when the path cannot be written", func(t *testing.T) {
+		err := conf.LoadAndUpdateFile(file, &c)
-			t.Parallel()
+		require.Error(t, err)
 
-			updated := false
+		assert.NoFileExists(t, file)
-			c := testconf{
-				String:    "default string",
-				Int:       1,
-				Invariant: "should not change",
-				inUpdate:  func() { updated = true },
-			}
-			tmpDir := t.TempDir()
-			file := filepath.Join(tmpDir, "does-not-exist", "test."+ext)
 
-			err := conf.LoadAndUpdateFile(file, &c)
+		assert.False(t, updated)
-			require.Error(t, err)
+	})
 
-			assert.NoFileExists(t, file)
+	t.Run("when the config file is invalid", func(t *testing.T) {
+		t.Parallel()
 
-			assert.False(t, updated)
+		updated := false
-		})
+		c := testconf{
+			String:    "default string",
+			Int:       1,
+			Invariant: "should not change",
+			inUpdate:  func() { updated = true },
+		}
+		tmpDir := t.TempDir()
+		file := filepath.Join(tmpDir, "test.conf")
 
-		t.Run("when the config file is invalid", func(t *testing.T) {
+		content := []byte(`String: not json`)
-			t.Parallel()
+		err := os.WriteFile(file, content, 0o644)
+		require.NoError(t, err)
 
-			updated := false
+		err = conf.LoadAndUpdateFile(file, &c)
-			c := testconf{
+		require.Error(t, err)
-				String:    "default string",
-				Int:       1,
-				Invariant: "should not change",
-				inUpdate:  func() { updated = true },
-			}
-			tmpDir := t.TempDir()
-			file := filepath.Join(tmpDir, "test."+ext)
 
-			content, err := os.ReadFile("test_data/invalid." + ext)
+		assert.False(t, updated)
-			require.NoError(t, err)
+	})
 
-			err = os.WriteFile(file, content, 0o600)
+	t.Run("when the config file is valid", func(t *testing.T) {
-			require.NoError(t, err)
+		t.Parallel()
 
-			err = conf.LoadAndUpdateFile("test_data/invalid."+ext, &c)
+		updated := false
-			require.Error(t, err)
+		c := testconf{
+			String:    "default string",
+			Int:       1,
+			Invariant: "should not change",
+			inUpdate:  func() { updated = true },
+		}
+		tmpDir := t.TempDir()
+		file := filepath.Join(tmpDir, "test.conf")
 
-			assert.False(t, updated)
+		content := []byte(`{"String": "config string", "Int": 42}`)
-		})
+		err := os.WriteFile(file, content, 0o644)
+		require.NoError(t, err)
 
-		t.Run("when the config file is valid", func(t *testing.T) {
+		err = conf.LoadAndUpdateFile(file, &c)
-			t.Parallel()
+		require.NoError(t, err)
 
-			updated := false
+		var c2 testconf
-			c := testconf{
+		err = conf.LoadFile(file, &c2)
-				String:    "default string",
+		require.NoError(t, err)
-				Int:       1,
+		assert.Equal(t, "config string", c2.String)
-				Invariant: "should not change",
+		assert.Equal(t, 42, c2.Int)
-				inUpdate:  func() { updated = true },
-			}
-			tmpDir := t.TempDir()
-			file := filepath.Join(tmpDir, "test."+ext)
 
-			content, err := os.ReadFile("test_data/valid." + ext)
+		assert.True(t, updated)
-			require.NoError(t, err)
+	})
 
-			err = os.WriteFile(file, content, 0o600)
+	t.Run("when the config file is missing options", func(t *testing.T) {
-			require.NoError(t, err)
+		t.Parallel()
 
-			err = conf.LoadAndUpdateFile(file, &c)
+		updated := false
-			require.NoError(t, err)
+		c := testconf{
+			String:    "default string",
+			Int:       1,
+			Invariant: "should not change",
+			inUpdate:  func() { updated = true },
+		}
+		tmpDir := t.TempDir()
+		file := filepath.Join(tmpDir, "test.conf")
 
-			var c2 testconf
+		content := []byte(`{"String": "config string"}`)
-			err = conf.LoadFile(file, &c2)
+		err := os.WriteFile(file, content, 0o644)
-			require.NoError(t, err)
+		require.NoError(t, err)
-			assert.Equal(t, "config string", c2.String)
-			assert.Equal(t, 42, c2.Int)
-			assert.Equal(t, "should not change", c2.Invariant)
 
-			assert.True(t, updated)
+		err = conf.LoadAndUpdateFile(file, &c)
-		})
+		require.NoError(t, err)
 
-		t.Run("when the config file is missing options", func(t *testing.T) {
+		newContent, err := os.ReadFile(file)
-			t.Parallel()
+		require.NoError(t, err)
 
-			updated := false
+		assert.Contains(t, string(newContent), "Int") //nolint:usestdlibvars // not the constant here
-			c := testconf{
+		assert.Contains(t, string(newContent), "Invariant")
-				String:    "default string",
-				Int:       1,
-				Invariant: "should not change",
-				inUpdate:  func() { updated = true },
-			}
-			tmpDir := t.TempDir()
-			file := filepath.Join(tmpDir, "test."+ext)
 
-			content, err := os.ReadFile("test_data/valid." + ext)
+		assert.True(t, updated)
-			require.NoError(t, err)
+	})
 
-			err = os.WriteFile(file, content, 0o600)
+	t.Run("when the config contains unknown options", func(t *testing.T) {
-			require.NoError(t, err)
+		t.Parallel()
 
-			err = conf.LoadAndUpdateFile(file, &c)
+		updated := false
-			require.NoError(t, err)
+		c := testconf{
+			String:    "default string",
+			Int:       1,
+			Invariant: "should not change",
+			inUpdate:  func() { updated = true },
+		}
+		tmpDir := t.TempDir()
+		file := filepath.Join(tmpDir, "test.conf")
 
-			newContent, err := os.ReadFile(file)
+		content := []byte(`{"String": "config string", "Foo": "blah"}`)
-			require.NoError(t, err)
+		err := os.WriteFile(file, content, 0o644)
+		require.NoError(t, err)
 
-			assert.Contains(t, string(newContent), "Invariant")
+		err = conf.LoadAndUpdateFile(file, &c)
+		require.NoError(t, err)
 
-			assert.True(t, updated)
+		newContent, err := os.ReadFile(file)
-		})
+		require.NoError(t, err)
+		assert.NotContains(t, string(newContent), "Foo")
 
-		t.Run("when the config contains unknown options", func(t *testing.T) {
+		assert.True(t, updated)
-			t.Parallel()
-
-			updated := false
-			c := testconf{
-				String:    "default string",
-				Int:       1,
-				Invariant: "should not change",
-				inUpdate:  func() { updated = true },
-			}
-			tmpDir := t.TempDir()
-			file := filepath.Join(tmpDir, "test."+ext)
-
-			content, err := os.ReadFile("test_data/unknown." + ext)
-			require.NoError(t, err)
-
-			err = os.WriteFile(file, content, 0o600)
-			require.NoError(t, err)
-
-			err = conf.LoadAndUpdateFile(file, &c)
-			require.NoError(t, err)
-
-			newContent, err := os.ReadFile(file)
-			require.NoError(t, err)
-			assert.NotContains(t, string(newContent), "Unknown")
-
-			assert.True(t, updated)
-		})
 	})
 }

go.mod

@@ -6,7 +6,6 @@ require github.com/stretchr/testify v1.9.0
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,8 +1,6 @@
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 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/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
-github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
 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/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=

test_data/full.json

@@ -1,5 +0,0 @@
-{
-  "String": "default string",
-  "Invariant": "should not change",
-  "Int": 1
-}

test_data/full.toml

@@ -1,3 +0,0 @@
-String = 'default string'
-Invariant = 'should not change'
-Int = 1

test_data/invalid.toml

@@ -1 +0,0 @@
-String: not toml

test_data/part1.json

@@ -1 +0,0 @@
-{"String": "foo"}

test_data/part1.toml

@@ -1 +0,0 @@
-String = "foo"

test_data/part2.json

@@ -1 +0,0 @@
-{"Int": 42}

test_data/part2.toml

@@ -1 +0,0 @@
-Int = 42

test_data/same1.json

@@ -1 +0,0 @@
-{"String": "foo"}

test_data/same1.toml

@@ -1 +0,0 @@
-String = "foo"

test_data/same2.json

@@ -1 +0,0 @@
-{"String": "bar"}

test_data/same2.toml

@@ -1 +0,0 @@
-String = "bar"

test_data/unknown.json

@@ -1,5 +0,0 @@
-{
-    "String": "config string",
-    "Int": 42,
-    "Unknown": "foo"
-}

test_data/unknown.toml

@@ -1,3 +0,0 @@
-String = "config string"
-Int = 42
-Unknown = "foo"

test_data/valid.toml

@@ -1,2 +0,0 @@
-string = "config string"
-int = 42

test_data/valid.unknown

@@ -1 +0,0 @@
-String: not json