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
|
package tests
import (
"bytes"
"encoding/json"
"github.com/olekukonko/ll"
"github.com/olekukonko/ll/lh"
"github.com/olekukonko/ll/lx"
"log/slog"
"strings"
"testing"
)
// TestHandlers verifies the behavior of all log handlers (Text, Colorized, JSON, Slog, Multi).
func TestHandlers(t *testing.T) {
// Test TextHandler for plain text output
t.Run("TextHandler", func(t *testing.T) {
buf := &bytes.Buffer{}
logger := ll.New("test").Enable().Handler(lh.NewTextHandler(buf))
logger.Fields("key", "value").Infof("Test text")
if !strings.Contains(buf.String(), "[test] INFO: Test text [key=value]") {
t.Errorf("Expected %q to contain %q", buf.String(), "[test] INFO: Test text [key=value]")
}
})
// Test ColorizedHandler for ANSI-colored output
t.Run("ColorizedHandler", func(t *testing.T) {
buf := &bytes.Buffer{}
logger := ll.New("test").Enable().Handler(lh.NewColorizedHandler(buf))
logger.Fields("key", "value").Infof("Test color")
// Check for namespace presence, ignoring ANSI codes
if !strings.Contains(buf.String(), "[test]") {
t.Errorf("Expected %q to contain %q", buf.String(), "[test] INFO: Test color [key=value]")
}
})
// Test JSONHandler for structured JSON output
t.Run("JSONHandler", func(t *testing.T) {
buf := &bytes.Buffer{}
logger := ll.New("test").Enable().Handler(lh.NewJSONHandler(buf))
logger.Fields("key", "value").Infof("Test JSON")
// Parse JSON output and verify fields
var data lh.JsonOutput
if err := json.Unmarshal(buf.Bytes(), &data); err != nil {
t.Errorf("Expected no error, got %v", err)
}
if data.Level != lx.LevelInfo.String() {
t.Errorf("Expected level=%q, got %q", "INFO", data.Level)
}
if data.Msg != "Test JSON" {
t.Errorf("Expected message=%q, got %q", "Test JSON", data.Msg)
}
if data.Namespace != "test" {
t.Errorf("Expected namespace=%q, got %q", "test", data.Namespace)
}
f := data.Fields
if f["key"] != "value" {
t.Errorf("Expected key=%q, got %q", "value", f["key"])
}
})
// Test SlogHandler for compatibility with slog
t.Run("SlogHandler", func(t *testing.T) {
buf := &bytes.Buffer{}
logger := ll.New("test").Enable().Handler(lh.NewSlogHandler(slog.NewTextHandler(buf, nil)))
logger.Fields("key", "value").Infof("Test slog")
output := buf.String()
if !strings.Contains(output, "level=INFO") {
t.Errorf("Expected %q to contain %q", output, "level=INFO")
}
if !strings.Contains(output, "msg=\"Test slog\"") {
t.Errorf("Expected %q to contain %q", output, "msg=\"Test slog\"")
}
if !strings.Contains(output, "namespace=test") {
t.Errorf("Expected %q to contain %q", output, "namespace=test")
}
if !strings.Contains(output, "key=value") {
t.Errorf("Expected %q to contain %q", output, "key=value")
}
})
// Test MultiHandler for combining multiple handlers
t.Run("MultiHandler", func(t *testing.T) {
buf1 := &bytes.Buffer{}
buf2 := &bytes.Buffer{}
logger := ll.New("test").Enable().Handler(lh.NewMultiHandler(
lh.NewTextHandler(buf1),
lh.NewJSONHandler(buf2),
))
logger.Fields("key", "value").Infof("Test multi")
// Verify TextHandler output
if !strings.Contains(buf1.String(), "[test] INFO: Test multi [key=value]") {
t.Errorf("Expected %q to contain %q", buf1.String(), "[test] INFO: Test multi [key=value]")
}
// Verify JSONHandler output
var data map[string]interface{}
if err := json.Unmarshal(buf2.Bytes(), &data); err != nil {
t.Errorf("Expected no error, got %v", err)
}
if data["msg"] != "Test multi" {
t.Errorf("Expected message=%q, got %q", "Test multi", data["msg"])
}
})
}
|
