ofelia/ofelia_test.go at main · netresearch/ofelia · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
// Copyright (c) 2025-2026 Netresearch DTT GmbH
// SPDX-License-Identifier: MIT

package main

import (
	"log/slog"
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestBuildLogger_ValidLevels(t *testing.T) {
	t.Parallel()
	testCases := []struct {
		name     string
		level    string
		expected slog.Level
	}{
		{"debug level", "debug", slog.LevelDebug},
		{"DEBUG uppercase", "DEBUG", slog.LevelDebug},
		{"trace level", "trace", slog.LevelDebug},
		{"info level", "info", slog.LevelInfo},
		{"INFO uppercase", "INFO", slog.LevelInfo},
		{"warn level", "warn", slog.LevelWarn},
		{"warning level", "warning", slog.LevelWarn},
		{"error level", "error", slog.LevelError},
		{"fatal level", "fatal", slog.LevelError},
		{"panic level", "panic", slog.LevelError},
		{"critical level", "critical", slog.LevelError},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()
			logger, lv := buildLogger(tc.level)
			assert.NotNil(t, logger)
			assert.Equal(t, tc.expected, lv.Level())
		})
	}
}

func TestBuildLogger_InvalidLevel_DefaultsToInfo(t *testing.T) {
	t.Parallel()
	testCases := []struct {
		name  string
		level string
	}{
		{"empty string", ""},
		{"invalid level", "invalid"},
		{"garbage", "xyz123"},
		{"numeric", "42"},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()
			logger, lv := buildLogger(tc.level)
			assert.NotNil(t, logger)
			assert.Equal(t, slog.LevelInfo, lv.Level(), "invalid level should default to Info")
		})
	}
}

func TestBuildLogger_ProducesWorkingLogger(t *testing.T) {
	t.Parallel()
	logger, lv := buildLogger("debug")
	assert.NotNil(t, logger)
	assert.NotNil(t, lv)

	// Should not panic when logging
	logger.Debug("test message", "key", "value")
	logger.Info("info message")
	logger.Warn("warn message")
}

func TestBuildLogger_ReturnsLevelVar(t *testing.T) {
	t.Parallel()
	_, lv := buildLogger("debug")
	assert.Equal(t, slog.LevelDebug, lv.Level())

	// LevelVar should be mutable
	lv.Set(slog.LevelError)
	assert.Equal(t, slog.LevelError, lv.Level())
}

func TestBuildLogger_LevelTransitions(t *testing.T) {
	t.Parallel()

	_, lv1 := buildLogger("debug")
	assert.Equal(t, slog.LevelDebug, lv1.Level())

	_, lv2 := buildLogger("error")
	assert.Equal(t, slog.LevelError, lv2.Level())

	_, lv3 := buildLogger("invalid")
	assert.Equal(t, slog.LevelInfo, lv3.Level(), "should default to info for invalid")
}

func TestBuildLogger_MixedCaseLevels(t *testing.T) {
	t.Parallel()
	testCases := []struct {
		input    string
		expected slog.Level
	}{
		{"DeBuG", slog.LevelDebug},
		{"INFO", slog.LevelInfo},
		{"WaRn", slog.LevelWarn},
		{"ERROR", slog.LevelError},
	}

	for _, tc := range testCases {
		t.Run(tc.input, func(t *testing.T) {
			t.Parallel()
			_, lv := buildLogger(tc.input)
			assert.Equal(t, tc.expected, lv.Level())
		})
	}
}

func TestBuildLogger_LoggerHasSourceEnabled(t *testing.T) {
	t.Parallel()
	logger, _ := buildLogger("debug")
	assert.NotNil(t, logger)
	// The handler is configured with AddSource: true
	// We verify by ensuring the logger was created successfully
	// (source inclusion is verified by the handler options)
}