config: Increase test coverage

diff --git a/config/configLoader_test.go b/config/configLoader_test.go
index 5460313344f573dd1feb03fbfe903e9d6137a7d8..a2d16fba75b8ef0da48a3208c7e6584ba151e7b9 100644 (file)
--- a/config/configLoader_test.go
+++ b/config/configLoader_test.go
@@ -14,6 +14,7 @@
 package config
 
 import (
+       "regexp"
        "strings"
        "testing"
 
@@ -32,3 +33,13 @@ func TestIsValidConfigFileName(t *testing.T) {
        c.Assert(IsValidConfigFilename(""), qt.Equals, false)
        c.Assert(IsValidConfigFilename("config.toml.swp"), qt.Equals, false)
 }
+
+func TestFromTOMLConfigString(t *testing.T) {
+       c := qt.New(t)
+
+       c.Assert(
+               func() { FromTOMLConfigString("cfg") },
+               qt.PanicMatches,
+               regexp.MustCompile("_stream.toml:.*"),
+       )
+}

diff --git a/config/defaultConfigProvider_test.go b/config/defaultConfigProvider_test.go
index cd6247e604a4d255db637ff674fe2d989e104763..204861216a82e758b8a38f7799c6c9372f4a5d41 100644 (file)
--- a/config/defaultConfigProvider_test.go
+++ b/config/defaultConfigProvider_test.go
@@ -17,6 +17,7 @@ import (
        "context"
        "errors"
        "fmt"
+       "slices"
        "strconv"
        "strings"
        "testing"
@@ -353,6 +354,90 @@ func TestDefaultConfigProvider(t *testing.T) {
 
                c.Assert(r.Wait(), qt.IsNil)
        })
+
+       c.Run("GetBool", func(c *qt.C) {
+               cfg := New()
+
+               var k string
+               var v bool
+
+               k, v = "foo", true
+
+               cfg.Set(k, v)
+               c.Assert(cfg.Get(k), qt.Equals, v)
+               c.Assert(cfg.GetBool(k), qt.Equals, v)
+       })
+
+       c.Run("GetParams", func(c *qt.C) {
+               cfg := New()
+               k := "foo"
+
+               cfg.Set(k, maps.Params{k: true})
+               c.Assert(cfg.GetParams(k), qt.DeepEquals, maps.Params{
+                       k: true,
+               })
+
+               c.Assert(cfg.GetParams("bar"), qt.IsNil)
+       })
+
+       c.Run("Keys", func(c *qt.C) {
+               cfg := New()
+               k := "foo"
+               k2 := "bar"
+
+               cfg.Set(k, maps.Params{k: struct{}{}})
+               cfg.Set(k2, maps.Params{k2: struct{}{}})
+
+               c.Assert(len(cfg.Keys()), qt.Equals, 2)
+
+               got := cfg.Keys()
+               slices.Sort(got)
+
+               want := []string{k, k2}
+               slices.Sort(want)
+
+               c.Assert(got, qt.DeepEquals, want)
+       })
+
+       c.Run("WalkParams", func(c *qt.C) {
+               cfg := New()
+
+               cfg.Set("x", maps.Params{})
+               cfg.Set("y", maps.Params{})
+
+               var got []string
+               cfg.WalkParams(func(params ...maps.KeyParams) bool {
+                       got = append(got, params[len(params)-1].Key)
+                       return false
+               })
+
+               want := []string{"", "x", "y"}
+               slices.Sort(got)
+               slices.Sort(want)
+
+               c.Assert(got, qt.DeepEquals, want)
+
+               cfg = New()
+               cfg.WalkParams(func(params ...maps.KeyParams) bool {
+                       return true
+               })
+
+               got = []string{""}
+               want = []string{""}
+               c.Assert(got, qt.DeepEquals, want)
+       })
+
+       c.Run("SetDefaults", func(c *qt.C) {
+               cfg := New()
+
+               cfg.SetDefaults(maps.Params{
+                       "foo": "bar",
+                       "bar": "baz",
+               })
+
+               c.Assert(cfg.Get("foo"), qt.Equals, "bar")
+               c.Assert(cfg.Get("bar"), qt.Equals, "baz")
+       })
 }
 
 func BenchmarkDefaultConfigProvider(b *testing.B) {