Debian Codegraph @

launcher/internal/logging/logging_test.go

raw
1 package logging
2
3 import (
4 "bytes"
5 "errors"
6 "fmt"
7 "log/slog"
8 "reflect"
9 "strings"
10 "testing"
11
12 clogging "cloud.google.com/go/logging"
13 "github.com/google/go-cmp/cmp"
14 mrpb "google.golang.org/genproto/googleapis/api/monitoredres"
15 )
16
17 func toArgs(pl payload) []any {
18 args := []any{}
19 for k, v := range pl {
20 args = append(args, k)
21 args = append(args, v)
22 }
23
24 return args
25 }
26
27 func TestAddArgs(t *testing.T) {
28 testcases := []struct {
29 name string
30 args []any
31 expected payload
32 }{
33 {
34 name: "regular payload",
35 args: []any{"key1", 1, "key2", "two", "key3", false},
36 expected: payload{
37 "key1": 1,
38 "key2": "two",
39 "key3": false,
40 },
41 },
42 {
43 name: "missing value at end",
44 args: []any{"key1", 1, "key2", "two", "key3"},
45 expected: payload{
46 "key1": 1,
47 "key2": "two",
48 "key3": "",
49 },
50 },
51 {
52 name: "empty args",
53 args: []any{},
54 expected: payload{},
55 },
56 {
57 name: "incompatible key omitted",
58 args: []any{"key1", 1, 2, "two", "key3", false},
59 expected: payload{
60 "key1": 1,
61 "key3": false,
62 },
63 },
64 {
65 name: "single arg, valid key",
66 args: []any{"key1"},
67 expected: payload{
68 "key1": "",
69 },
70 },
71 {
72 name: "single arg, not valid key",
73 args: []any{true},
74 expected: payload{},
75 },
76 }
77
78 for _, tc := range testcases {
79 t.Run(tc.name, func(t *testing.T) {
80 pl := payload{}
81 addArgs(pl, tc.args)
82
83 if !reflect.DeepEqual(pl, tc.expected) {
84 t.Errorf("addArgs did not produce expected payload: got %v, want %v", pl, tc.expected)
85 }
86 })
87 }
88 }
89
90 // testCLogger implements the cLogger interface.
91 type testCLogger struct {
92 log clogging.Entry
93 }
94
95 func (c *testCLogger) Log(entry clogging.Entry) {
96 // Cloud Logging sends multiple messages - append everything together for simplicity.
97 c.log = entry
98 }
99
100 func (c *testCLogger) Flush() error { return nil }
101
102 // testSLogWriter implements the io.Writer interface.
103 type testSLogWriter struct {
104 log []byte
105 }
106
107 func (s *testSLogWriter) Write(p []byte) (n int, err error) {
108 s.log = p
109
110 return 0, nil
111 }
112
113 func (s *testSLogWriter) checkLogContains(msg string, pl payload) error {
114 if len(s.log) == 0 {
115 return errors.New("serial log is empty")
116 }
117
118 if !bytes.Contains(s.log, []byte(msg)) {
119 return fmt.Errorf("log did not contain expected message: got %s, want \"%s\"", s.log, msg)
120 }
121
122 if len(pl) > 0 {
123 strLogs := string(s.log)
124
125 // Check that each payload value is present in the format key=value.
126 for k, v := range pl {
127 format := "%v=%v"
128 if vStr, ok := v.(string); ok && strings.Contains(vStr, " ") {
129 format = "%v=\"%v\""
130 }
131
132 expectedStr := fmt.Sprintf(format, k, v)
133 if !strings.Contains(strLogs, expectedStr) {
134 return fmt.Errorf("logs expected to contain \"%s\", got \"%s\"", expectedStr, strLogs)
135 }
136 }
137 }
138
139 return nil
140 }
141
142 func (s *testSLogWriter) checkLogLevel(level slog.Level) error {
143 expected := "level=" + level.String()
144
145 if !strings.Contains(string(s.log), expected) {
146 return fmt.Errorf("log did not contain expected level %v: %v", expected, string(s.log))
147 }
148
149 return nil
150 }
151
152 func TestWriteLog(t *testing.T) {
153 testResource := &mrpb.MonitoredResource{
154 Type: "gce_instance",
155 Labels: map[string]string{
156 "instance_id": "1234",
157 "project_id": "not-a-real-project",
158 "zone": "us-central1-c",
159 },
160 }
161
162 // Redirect loggers to buffers.
163 cloudLogger := &testCLogger{}
164 serialLogs := &testSLogWriter{}
165
166 testLogger := &logger{
167 cloudLogger: cloudLogger,
168 serialLogger: slog.New(slog.NewTextHandler(serialLogs, nil)),
169 resource: testResource,
170
171 instanceName: "test-instance",
172 }
173
174 testMsg := "test message"
175 testPayload := payload{
176 "key1": "value1",
177 "key2": 2,
178 "key3": false,
179 }
180
181 testLogger.writeLog(clogging.Info, testMsg, toArgs(testPayload)...)
182
183 if err := serialLogs.checkLogContains(testMsg, testPayload); err != nil {
184 t.Errorf("Error validating Serial Log contents: %v", err)
185 }
186
187 if err := serialLogs.checkLogLevel(slog.LevelInfo); err != nil {
188 t.Errorf("Error validating Serial Log level: %v", err)
189 }
190
191 // Add message and hostnames values to expected payload.
192 testPayload[payloadMessageKey] = testMsg
193 testPayload[payloadInstanceNameKey] = testLogger.instanceName
194
195 if !cmp.Equal(cloudLogger.log.Payload, testPayload) {
196 t.Errorf("Did not get expected payload in cloud logs: got %v, want %v", cloudLogger.log.Payload, testPayload)
197 }
198
199 if cloudLogger.log.Severity != clogging.Info {
200 t.Errorf("Did not get expected severity in cloud logs: got %v, want %v", cloudLogger.log.Severity, clogging.Info)
201 }
202
203 // Compare monitored resource.
204 if cloudLogger.log.Resource.Type != testResource.Type {
205 t.Errorf("Did not get expected monitored resource tyoe: got %v, want %v", cloudLogger.log.Resource.Type, testResource.Type)
206 }
207
208 if !cmp.Equal(cloudLogger.log.Resource.Labels, testResource.Labels) {
209 t.Errorf("Did not get expected monitored resource labels in cloud logs: got %v, want %v", cloudLogger.log.Resource.Labels, testResource.Labels)
210 }
211 }
212
213 func TestLogFunctions(t *testing.T) {
214 testcases := []struct {
215 name string
216 cloudSeverity clogging.Severity
217 serialLevel slog.Level
218 logFunc func(lgr *logger, msg string)
219 }{
220 {
221 name: "logger.Info",
222 cloudSeverity: clogging.Info,
223 serialLevel: slog.LevelInfo,
224 logFunc: func(lgr *logger, msg string) {
225 lgr.Info(msg)
226 },
227 },
228 {
229 name: "logger.Warn",
230 cloudSeverity: clogging.Warning,
231 serialLevel: slog.LevelWarn,
232 logFunc: func(lgr *logger, msg string) {
233 lgr.Warn(msg)
234 },
235 },
236 {
237 name: "logger.Error",
238 cloudSeverity: clogging.Error,
239 serialLevel: slog.LevelError,
240 logFunc: func(lgr *logger, msg string) {
241 lgr.Error(msg)
242 },
243 },
244 }
245
246 msg := "test message"
247 for _, tc := range testcases {
248 t.Run(tc.name, func(t *testing.T) {
249
250 // Redirect loggers to buffers.
251 cloudLogs := &testCLogger{}
252 serialLogs := &testSLogWriter{}
253
254 testLogger := &logger{
255 cloudLogger: cloudLogs,
256 serialLogger: slog.New(slog.NewTextHandler(serialLogs, nil)),
257 instanceName: "test-instance",
258 }
259
260 tc.logFunc(testLogger, msg)
261
262 expectedPayload := payload{
263 payloadMessageKey: msg,
264 payloadInstanceNameKey: testLogger.instanceName,
265 }
266
267 if cloudLogs.log.Severity != tc.cloudSeverity {
268 t.Errorf("Cloud logs did not contain expected severity: got %v, want %v", cloudLogs.log.Severity, tc.cloudSeverity)
269 }
270
271 if !cmp.Equal(cloudLogs.log.Payload, expectedPayload) {
272 t.Errorf("Cloud logs did not contain expected payload: got %v, want %v", cloudLogs.log.Payload, expectedPayload)
273 }
274
275 if err := serialLogs.checkLogContains(msg, payload{}); err != nil {
276 t.Errorf("Error validating Serial Log contents: %v", err)
277 }
278
279 if err := serialLogs.checkLogLevel(tc.serialLevel); err != nil {
280 t.Errorf("Error validating Serial Log level: %v", err)
281 }
282 })
283 }
284 }