gitech

1
// Copyright 2023 The Gitea Authors. All rights reserved.
2
// SPDX-License-Identifier: MIT
3

4
package log
5

6
import (
7
	"context"
8
	"sync"
9
	"testing"
10
	"time"
11

12
	"github.com/stretchr/testify/assert"
13
)
14

15
type dummyWriter struct {
16
	*EventWriterBaseImpl
17

18
	delay time.Duration
19

20
	mu   sync.Mutex
21
	logs []string
22
}
23

24
func (d *dummyWriter) Write(p []byte) (n int, err error) {
25
	if d.delay > 0 {
26
		time.Sleep(d.delay)
27
	}
28
	d.mu.Lock()
29
	defer d.mu.Unlock()
30
	d.logs = append(d.logs, string(p))
31
	return len(p), nil
32
}
33

34
func (d *dummyWriter) Close() error {
35
	return nil
36
}
37

38
func (d *dummyWriter) GetLogs() []string {
39
	d.mu.Lock()
40
	defer d.mu.Unlock()
41
	logs := make([]string, len(d.logs))
42
	copy(logs, d.logs)
43
	return logs
44
}
45

46
func newDummyWriter(name string, level Level, delay time.Duration) *dummyWriter {
47
	w := &dummyWriter{
48
		EventWriterBaseImpl: NewEventWriterBase(name, "dummy", WriterMode{Level: level, Flags: FlagsFromBits(0)}),
49
	}
50
	w.delay = delay
51
	w.Base().OutputWriteCloser = w
52
	return w
53
}
54

55
func TestLogger(t *testing.T) {
56
	logger := NewLoggerWithWriters(context.Background(), "test")
57

58
	dump := logger.DumpWriters()
59
	assert.EqualValues(t, 0, len(dump))
60
	assert.EqualValues(t, NONE, logger.GetLevel())
61
	assert.False(t, logger.IsEnabled())
62

63
	w1 := newDummyWriter("dummy-1", DEBUG, 0)
64
	logger.AddWriters(w1)
65
	assert.EqualValues(t, DEBUG, logger.GetLevel())
66

67
	w2 := newDummyWriter("dummy-2", WARN, 200*time.Millisecond)
68
	logger.AddWriters(w2)
69
	assert.EqualValues(t, DEBUG, logger.GetLevel())
70

71
	dump = logger.DumpWriters()
72
	assert.EqualValues(t, 2, len(dump))
73

74
	logger.Trace("trace-level") // this level is not logged
75
	logger.Debug("debug-level")
76
	logger.Error("error-level")
77

78
	// w2 is slow, so only w1 has logs
79
	time.Sleep(100 * time.Millisecond)
80
	assert.Equal(t, []string{"debug-level\n", "error-level\n"}, w1.GetLogs())
81
	assert.Equal(t, []string{}, w2.GetLogs())
82

83
	logger.Close()
84

85
	// after Close, all logs are flushed
86
	assert.Equal(t, []string{"debug-level\n", "error-level\n"}, w1.GetLogs())
87
	assert.Equal(t, []string{"error-level\n"}, w2.GetLogs())
88
}
89

90
func TestLoggerPause(t *testing.T) {
91
	logger := NewLoggerWithWriters(context.Background(), "test")
92

93
	w1 := newDummyWriter("dummy-1", DEBUG, 0)
94
	logger.AddWriters(w1)
95

96
	GetManager().PauseAll()
97
	time.Sleep(50 * time.Millisecond)
98

99
	logger.Info("info-level")
100
	time.Sleep(100 * time.Millisecond)
101
	assert.Equal(t, []string{}, w1.GetLogs())
102

103
	GetManager().ResumeAll()
104

105
	time.Sleep(100 * time.Millisecond)
106
	assert.Equal(t, []string{"info-level\n"}, w1.GetLogs())
107

108
	logger.Close()
109
}
110

111
type testLogString struct {
112
	Field string
113
}
114

115
func (t testLogString) LogString() string {
116
	return "log-string"
117
}
118

119
func TestLoggerLogString(t *testing.T) {
120
	logger := NewLoggerWithWriters(context.Background(), "test")
121

122
	w1 := newDummyWriter("dummy-1", DEBUG, 0)
123
	w1.Mode.Colorize = true
124
	logger.AddWriters(w1)
125

126
	logger.Info("%s %s %#v %v", testLogString{}, &testLogString{}, testLogString{Field: "detail"}, NewColoredValue(testLogString{}, FgRed))
127
	logger.Close()
128

129
	assert.Equal(t, []string{"log-string log-string log.testLogString{Field:\"detail\"} \x1b[31mlog-string\x1b[0m\n"}, w1.GetLogs())
130
}
131

132
func TestLoggerExpressionFilter(t *testing.T) {
133
	logger := NewLoggerWithWriters(context.Background(), "test")
134

135
	w1 := newDummyWriter("dummy-1", DEBUG, 0)
136
	w1.Mode.Expression = "foo.*"
137
	logger.AddWriters(w1)
138

139
	logger.Info("foo")
140
	logger.Info("bar")
141
	logger.Info("foo bar")
142
	logger.SendLogEvent(&Event{Level: INFO, Filename: "foo.go", MsgSimpleText: "by filename"})
143
	logger.Close()
144

145
	assert.Equal(t, []string{"foo\n", "foo bar\n", "by filename\n"}, w1.GetLogs())
146
}
147