danvics/Pulse
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add unit tests for parseLogLevel and splitStringList (dockeragent)

Browse source
This commit is contained in:
rcourtman 2025-11-30 06:50:09 +00:00
parent d69e1545f2
commit e8bf978544
1 changed files with 307 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

307
cmd/pulse-docker-agent/main_test.go
View file

@ -1,9 +1,12 @@
package main package main
import ( import (
"reflect"
"strings"
"testing" "testing"
"github.com/rcourtman/pulse-go-rewrite/internal/dockeragent" "github.com/rcourtman/pulse-go-rewrite/internal/dockeragent"
"github.com/rs/zerolog"
) )
func TestParseTargetSpec(t *testing.T) { func TestParseTargetSpec(t *testing.T) {
@ -85,3 +88,307 @@ func TestSplitTargetSpecs(t *testing.T) {
} }
} }
} }
func TestParseLogLevel(t *testing.T) {
tests := []struct {
name string
input string
wantLevel zerolog.Level
wantErr bool
errSubstr string
}{
// Valid levels
{
name: "debug level",
input: "debug",
wantLevel: zerolog.DebugLevel,
},
{
name: "info level",
input: "info",
wantLevel: zerolog.InfoLevel,
},
{
name: "warn level",
input: "warn",
wantLevel: zerolog.WarnLevel,
},
{
name: "error level",
input: "error",
wantLevel: zerolog.ErrorLevel,
},
{
name: "trace level",
input: "trace",
wantLevel: zerolog.TraceLevel,
},
// Case insensitivity
{
name: "uppercase DEBUG",
input: "DEBUG",
wantLevel: zerolog.DebugLevel,
},
{
name: "mixed case Info",
input: "Info",
wantLevel: zerolog.InfoLevel,
},
{
name: "uppercase WARN",
input: "WARN",
wantLevel: zerolog.WarnLevel,
},
// Whitespace handling
{
name: "leading whitespace",
input: " debug",
wantLevel: zerolog.DebugLevel,
},
{
name: "trailing whitespace",
input: "warn ",
wantLevel: zerolog.WarnLevel,
},
{
name: "both whitespace",
input: " error ",
wantLevel: zerolog.ErrorLevel,
},
{
name: "tabs",
input: "\tinfo\t",
wantLevel: zerolog.InfoLevel,
},
// Empty string defaults to info
{
name: "empty string defaults to info",
input: "",
wantLevel: zerolog.InfoLevel,
},
{
name: "whitespace only defaults to info",
input: " ",
wantLevel: zerolog.InfoLevel,
},
{
name: "tabs only defaults to info",
input: "\t\t",
wantLevel: zerolog.InfoLevel,
},
// Invalid levels
{
name: "invalid level returns error",
input: "invalid",
wantLevel: zerolog.InfoLevel,
wantErr: true,
errSubstr: "invalid log level",
},
{
name: "typo returns error",
input: "debuf",
wantLevel: zerolog.InfoLevel,
wantErr: true,
errSubstr: "must be debug, info, warn, or error",
},
{
name: "numeric 1 maps to info level",
input: "1",
wantLevel: zerolog.InfoLevel,
},
{
name: "numeric 0 maps to debug level",
input: "0",
wantLevel: zerolog.DebugLevel,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
level, err := parseLogLevel(tt.input)
if tt.wantErr {
if err == nil {
t.Fatalf("expected error, got nil")
}
if tt.errSubstr != "" && !strings.Contains(err.Error(), tt.errSubstr) {
t.Fatalf("expected error containing %q, got %q", tt.errSubstr, err.Error())
}
} else {
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
}
if level != tt.wantLevel {
t.Fatalf("expected level %v, got %v", tt.wantLevel, level)
}
})
}
}
func TestSplitStringList(t *testing.T) {
tests := []struct {
name string
input string
want []string
}{
// Empty input
{
name: "empty string returns nil",
input: "",
want: nil,
},
// Single item
{
name: "single item",
input: "foo",
want: []string{"foo"},
},
{
name: "single item with whitespace",
input: " foo ",
want: []string{"foo"},
},
// Comma delimiter
{
name: "comma separated",
input: "foo,bar,baz",
want: []string{"foo", "bar", "baz"},
},
{
name: "comma with spaces",
input: "foo, bar, baz",
want: []string{"foo", "bar", "baz"},
},
{
name: "comma with extra spaces",
input: " foo , bar , baz ",
want: []string{"foo", "bar", "baz"},
},
// Semicolon delimiter
{
name: "semicolon separated",
input: "foo;bar;baz",
want: []string{"foo", "bar", "baz"},
},
{
name: "semicolon with spaces",
input: "foo; bar; baz",
want: []string{"foo", "bar", "baz"},
},
// Newline delimiter
{
name: "newline separated",
input: "foo\nbar\nbaz",
want: []string{"foo", "bar", "baz"},
},
{
name: "newline with spaces",
input: "foo \n bar \n baz",
want: []string{"foo", "bar", "baz"},
},
// Carriage return delimiter
{
name: "carriage return separated",
input: "foo\rbar\rbaz",
want: []string{"foo", "bar", "baz"},
},
{
name: "CRLF (Windows line ending)",
input: "foo\r\nbar\r\nbaz",
want: []string{"foo", "bar", "baz"},
},
// Mixed delimiters
{
name: "mixed comma and semicolon",
input: "foo,bar;baz",
want: []string{"foo", "bar", "baz"},
},
{
name: "mixed all delimiters",
input: "a,b;c\nd\re",
want: []string{"a", "b", "c", "d", "e"},
},
{
name: "mixed with spaces",
input: "a , b ; c \n d \r e",
want: []string{"a", "b", "c", "d", "e"},
},
// Consecutive delimiters (should be filtered)
{
name: "double comma",
input: "foo,,bar",
want: []string{"foo", "bar"},
},
{
name: "multiple consecutive delimiters",
input: "foo,,,bar;;;baz",
want: []string{"foo", "bar", "baz"},
},
{
name: "trailing delimiter",
input: "foo,bar,",
want: []string{"foo", "bar"},
},
{
name: "leading delimiter",
input: ",foo,bar",
want: []string{"foo", "bar"},
},
{
name: "only delimiters returns empty slice",
input: ",;,;",
want: []string{},
},
// Whitespace-only items filtered
{
name: "whitespace between delimiters filtered",
input: "foo, ,bar",
want: []string{"foo", "bar"},
},
{
name: "tabs between delimiters filtered",
input: "foo,\t\t,bar",
want: []string{"foo", "bar"},
},
// Real-world examples
{
name: "network names list",
input: "bridge, host, none",
want: []string{"bridge", "host", "none"},
},
{
name: "container IDs",
input: "abc123;def456;ghi789",
want: []string{"abc123", "def456", "ghi789"},
},
{
name: "multiline config",
input: "web\napi\nworker",
want: []string{"web", "api", "worker"},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := splitStringList(tt.input)
if !reflect.DeepEqual(got, tt.want) {
t.Fatalf("expected %v, got %v", tt.want, got)
}
})
}
}