-
Notifications
You must be signed in to change notification settings - Fork 1
/
logruswr_test.go
271 lines (220 loc) · 6.25 KB
/
logruswr_test.go
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
package logruswr
import (
"bytes"
"context"
"errors"
"log"
"os"
"strings"
"testing"
"github.com/thiagozs/go-logruswr/hooks"
)
func TestLogWrapper_WithField(t *testing.T) {
logger, err := New()
if err != nil {
t.Fatalf("Failed to create logger: %v", err)
}
entry := logger.WithField("key", "value")
if entry.Data["key"] != "value" {
t.Errorf("Expected field 'key' to be 'value', got '%v'", entry.Data["key"])
}
}
func TestLogWrapper_WithFields(t *testing.T) {
logger, err := New()
if err != nil {
t.Fatalf("Failed to create logger: %v", err)
}
fields := Fields{"key1": "value1", "key2": "value2"}
entry := logger.WithFields(fields)
for k, v := range fields {
if entry.Data[k] != v {
t.Errorf("Expected field '%s' to be '%v', got '%v'", k, v, entry.Data[k])
}
}
}
func TestLogWrapper_WithError(t *testing.T) {
logger, err := New()
if err != nil {
t.Fatalf("Failed to create logger: %v", err)
}
testError := errors.New("test error")
entry := logger.WithError(testError)
if entry.Data["error"] != testError {
t.Errorf("Expected error to be '%v', got '%v'", testError, entry.Data["error"])
}
}
func TestLogWrapper_LogLevels(t *testing.T) {
var buf bytes.Buffer
logger, err := New(WithOutput(Stdout))
if err != nil {
t.Fatalf("Failed to create logger: %v", err)
}
// Redirect log output to buffer
logger.log.SetOutput(&buf)
// Set log level to Info, should not log Debug
logger.SetLevel(Info)
logger.Debug("This is a debug message that should not appear")
if buf.Len() > 0 {
t.Error("Debug message was logged when log level was set to Info")
}
buf.Reset() // Clear buffer
// Log at Info level, should appear
logger.Info("Test1 message")
if !strings.Contains(buf.String(), "Test1 message") {
t.Error("The message are not the same on Info")
}
buf.Reset() // Clear buffer
// Log at Error level, should appear
logger.Error("Test2 message")
if !strings.Contains(buf.String(), "Test2 message") {
t.Error("The message are not the same on Info")
}
buf.Reset() // Clear buffer
logger.Warn("Test3 message")
if !strings.Contains(buf.String(), "Test3 message") {
t.Error("The message are not the same on Warn")
}
buf.Reset() // Clear buffer
logger.Trace("Test4 message")
if buf.Len() > 0 {
t.Error("Trace message was logged when log level was set to Info")
}
buf.Reset() // Clear buffer
}
func TestLogWrapper_LogLevelsPanic(t *testing.T) {
defer func() {
if r := recover(); r == nil {
t.Errorf("The code did not panic")
}
}()
logger, err := New(WithOutput(Stdout))
if err != nil {
t.Fatalf("Failed to create logger: %v", err)
}
// Set log level to Panic, should panic
logger.SetLevel(Panic)
logger.Panic("This is a panic message")
}
func TestLogWrapper_AddHooks(t *testing.T) {
logger, err := New(WithOutput(Stdout))
if err != nil {
t.Fatalf("Failed to create logger: %v", err)
}
hook := &hooks.TestHook{}
logger.AddHook(hook)
logger.Info("Test message")
if !hook.IsFired() {
t.Error("The hook was not called")
}
}
func TestLogWrapper_WithContext(t *testing.T) {
logger, err := New(WithOutput(Stdout))
if err != nil {
t.Fatalf("Failed to create logger: %v", err)
}
ctx := context.Background()
logger.WithContext(ctx).Info("Test message")
}
func TestLogWrapper_WithFormatter(t *testing.T) {
logger, err := New(WithOutput(Stdout), WithFormatter(FormatterJSON))
if err != nil {
t.Fatalf("Failed to create logger: %v", err)
}
logger.Info("Test message")
}
func TestLogWrapper_LogFilePath(t *testing.T) {
defer func() {
if err := os.Remove("/tmp/myapp.log"); err != nil {
log.Fatalf("Failed to remove log file: %v", err)
}
}()
logger, err := New(
WithFormatter(FormatterJSON),
WithOutput(File),
WithLevel(Info),
WithLogFilePath("/tmp/myapp.log"),
WithMaxLogSize(10), // Rotate after 10 MB
WithMaxBackups(3), // Keep only 3 log files
WithMaxAge(28), // 28 days
WithCompressLogs(true), // Compress old log files
)
if err != nil {
log.Fatalf("Failed to initialize logger: %v", err)
}
logger.Info("Test1 message")
// open file and check if the message is there
f, err := os.Open("/tmp/myapp.log")
if err != nil {
log.Fatalf("Failed to open log file: %v", err)
}
buf := make([]byte, 1024)
n, err := f.Read(buf)
if err != nil {
log.Fatalf("Failed to read log file: %v", err)
}
if !strings.Contains(string(buf[:n]), "Test1 message") {
log.Fatalf("Log message not found in file")
}
}
func TestLogWrapper_LogFilePathNoFile(t *testing.T) {
logger, err := New(
WithFormatter(FormatterJSON),
WithOutput(File),
WithLevel(Info),
WithLogFilePath(""),
)
if err != nil {
t.Fatalf("Failed to initialize logger: %v", err)
}
logger.Info("Test1 message")
}
func TestLogWrapper_Constants(t *testing.T) {
if FormatterText.String() != "text" {
t.Errorf("Expected FormatterText.String() to be 'text', got '%s'", FormatterText.String())
}
if FormatterJSON.String() != "json" {
t.Errorf("Expected FormatterJSON.String() to be 'json', got '%s'", FormatterJSON.String())
}
if Panic.String() != "panic" {
t.Errorf("Expected LevelPanic.String() to be 'panic', got '%s'", Panic.String())
}
if Fatal.String() != "fatal" {
t.Errorf("Expected LevelFatal.String() to be 'fatal', got '%s'", Fatal.String())
}
if Error.String() != "error" {
t.Errorf("Expected LevelError.String() to be 'error', got '%s'", Error.String())
}
if Warn.String() != "warn" {
t.Errorf("Expected LevelWarn.String() to be 'warn', got '%s'", Warn.String())
}
if Info.String() != "info" {
t.Errorf("Expected LevelInfo.String() to be 'info', got '%s'", Info.String())
}
if Debug.String() != "debug" {
t.Errorf("Expected LevelDebug.String() to be 'debug', got '%s'", Debug.String())
}
if Trace.String() != "trace" {
t.Errorf("Expected LevelTrace.String() to be 'trace', got '%s'", Trace.String())
}
}
func TestLogWrapper_MarshalText(t *testing.T) {
l := Info
b, err := l.MarshalText()
if err != nil {
t.Errorf("Expected no error, got %v", err)
}
t.Logf("baaa: %s", b)
if string(b) != Info.String() {
t.Errorf("Expected 'info', got %s", string(b))
}
}
func TestLogWrapper_UnmarshalText(t *testing.T) {
var l Level
err := l.UnmarshalText([]byte("info"))
if err != nil {
t.Errorf("Expected no error, got %v", err)
}
if l != Info {
t.Errorf("Expected 'info', got %v", l)
}
}