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
|
package testhelper
import (
"bytes"
"os"
"path/filepath"
"sync"
"testing"
"github.com/sirupsen/logrus"
"github.com/sirupsen/logrus/hooks/test"
"github.com/stretchr/testify/require"
"gitlab.com/gitlab-org/gitaly/v16/internal/helper/perm"
"gitlab.com/gitlab-org/gitaly/v16/internal/log"
)
var (
// sharedLoggersMutex protects the sharedLoggers map below.
sharedLoggersMutex sync.Mutex
// sharedLogger contains test case specific loggers keyed by the test name.
// sharedLoggersMutex should be acquired before accessing the map.
sharedLoggers = map[string]log.LogrusLogger{}
)
// SharedLogger returns a logger that is global to the running test case.
// When called first time during a test, a new logger is created and
// returned. All follow up calls to SharedLogger return the same logger
// instance.
//
// This is more of a workaround. It would be preferable to inject the
// same logger returned from the first call everywhere in the test. We
// have however a large number of tests which are creating new loggers
// all over the place instead of passing the logger around. This sharing
// mechanism serves as a workaround to use the same logger everywhere in
// the same test case. Using the same logger ensures the log messages
// are properly ordered.
func SharedLogger(tb testing.TB) log.LogrusLogger {
sharedLoggersMutex.Lock()
defer sharedLoggersMutex.Unlock()
if logger, ok := sharedLoggers[tb.Name()]; ok {
return logger
}
logger := NewLogger(tb, WithLoggerName("shared-logger"))
sharedLoggers[tb.Name()] = logger
tb.Cleanup(func() {
sharedLoggersMutex.Lock()
delete(sharedLoggers, tb.Name())
sharedLoggersMutex.Unlock()
})
return logger
}
type loggerOptions struct {
name string
}
// LoggerOption configures a logger.
type LoggerOption func(*loggerOptions)
// WithLoggerName sets the name of the logger. The name is included along
// the logs to help identifying the logs if multiple loggers are used.
func WithLoggerName(name string) LoggerOption {
return func(opts *loggerOptions) {
opts.name = name
}
}
// NewLogger returns a logger that records the log output and
// prints it out only if the test fails.
func NewLogger(tb testing.TB, options ...LoggerOption) log.LogrusLogger {
logOutput := &bytes.Buffer{}
logger := logrus.New() //nolint:forbidigo
logger.Out = logOutput
var opts loggerOptions
for _, apply := range options {
apply(&opts)
}
tb.Cleanup(func() {
if !tb.Failed() {
return
}
if opts.name != "" {
tb.Logf("Recorded logs of %q:\n%s\n", opts.name, logOutput)
} else {
tb.Logf("Recorded test logs:\n%s\n", logOutput)
}
})
return log.FromLogrusEntry(logrus.NewEntry(logger))
}
// LoggerHook is a hook that can be installed on the test logger in order to intercept log entries.
type LoggerHook struct {
hook *test.Hook
}
// AddLoggerHook installs a hook on the logger.
func AddLoggerHook(logger log.LogrusLogger) LoggerHook {
return LoggerHook{hook: test.NewLocal(logger.LogrusEntry().Logger)} //nolint:staticcheck
}
// AllEntries returns all log entries that have been intercepted by the hook.
func (h LoggerHook) AllEntries() []*logrus.Entry {
return h.hook.AllEntries()
}
// LastEntry returns the last log entry or `nil` if there are no logged entries.
func (h LoggerHook) LastEntry() *logrus.Entry {
return h.hook.LastEntry()
}
// Reset empties the list of intercepted log entries.
func (h LoggerHook) Reset() {
h.hook.Reset()
}
// CreateTestLogDir creates a new log directory for testing purposes if the environment variable
// `TEST_LOG_DIR` is set. The log directory will then be created as a subdirectory of the value that
// `TEST_LOG_DIR` points to. The name of the subdirectory will match the executing test's name.
//
// Returns the name of the created log directory. If the environment variable is not set then this
// functions returns an empty string.
func CreateTestLogDir(tb testing.TB) string {
testLogDir := os.Getenv("TEST_LOG_DIR")
if len(testLogDir) == 0 {
return ""
}
logDir := filepath.Join(testLogDir, tb.Name())
require.NoError(tb, os.MkdirAll(logDir, perm.SharedDir))
return logDir
}
|
