go.temporal.io/server/tools/testrunner/log.go
444 LOC · 251 covered · 193 uncovered · 77 ranges · 48 concepts · 23 introducers · 31 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
package testrunner
2
3
import (
4
"fmt"
5
"io"
6
"slices"
7
"strings"
8
9
"github.com/maruel/panicparse/v2/stack"
10
)
11
12
const (
13
// noFailureDetails is returned by parseFailureDetails when no recognisable
14
// failure block is found.
15
noFailureDetails = "(error details not found)"
16
goTestFailLinePrefix = "--- FAIL:"
17
)
18
19
// parseTestTimeouts parses the stdout of a test run and returns the stacktrace and names of tests that timed out.
21
>
lines := strings.Split(strings.ReplaceAll(stdout, "\r\n", "\n"), "\n")
22
>
for i := 0; i < len(lines); i++ {
23
>
line := lines[i]
24
>
if strings.HasPrefix(line, "FAIL") {
25
>
// ignore
26
>
} else if strings.HasPrefix(line, "panic: test timed out after") {
27
>
// parse names of tests that timed out
28
>
for {
29
>
i++
30
>
line = strings.TrimSpace(lines[i])
31
>
if strings.HasPrefix(line, "Test") {
32
>
timedoutTests = append(timedoutTests, strings.Split(line, " ")[0])
33
>
}
34
>
if line == "" {
35
>
break
36
}
37
}
39
>
// collect stracktrace
40
>
stacktrace += line + "\n"
41
>
}
42
}
43
45
>
len(timedoutTests), strings.Join(timedoutTests, "\n\t"), testOnlyStacktrace(stacktrace))
46
>
return
47
}
48
49
// testOnlyStacktrace removes all but the test stacktraces from the full stacktrace.
51
>
var res string
52
>
snap, _, err := stack.ScanSnapshot(strings.NewReader(stacktrace), io.Discard, stack.DefaultOpts())
53
>
if err != nil && err != io.EOF {
54
return fmt.Sprintf("failed to parse stacktrace: %v", err)
55
}
57
return "failed to find a stacktrace"
58
}
60
>
for _, goroutine := range snap.Goroutines {
61
>
shouldPrint := slices.ContainsFunc(goroutine.Stack.Calls, func(call stack.Call) bool {
62
>
return strings.HasSuffix(call.RemoteSrcPath, "_test.go")
63
>
})
64
>
if shouldPrint {
65
>
res += fmt.Sprintf("\tgoroutine %d [%v]:\n", goroutine.ID, goroutine.State)
66
>
for _, call := range goroutine.Stack.Calls {
67
>
file := call.RemoteSrcPath
68
>
res += fmt.Sprintf("\t\t%s:%d\n", file, call.Line)
69
>
}
70
>
res += "\n"
71
}
72
}
74
}
75
76
// alert captures a prominent issue detected from stdout/stderr of test runs.
77
type alert struct {
78
Type failureType
79
Summary string
80
Details string
81
Tests []string
82
}
83
84
// primaryTestName returns a single representative test name for an alert.
85
// Preference order:
86
// 1) Fully-qualified test name containing ".Test"
87
// 2) First detected test name
89
>
if len(tests) == 0 {
90
return ""
91
}
93
>
if strings.Contains(t, ".Test") {
95
>
}
96
}
98
}
99
100
// preferFullyQualifiedTestName returns the best display name for a test.
101
// If the primary name is not fully-qualified (e.g., "TestXxx"), but a
102
// fully-qualified variant exists in the list (e.g., "pkg/path.TestXxx"),
103
// this returns the fully-qualified variant.
104
func preferFullyQualifiedTestName(tests []string) string {
105
primary := primaryTestName(tests)
106
if primary == "" || strings.Contains(primary, ".Test") {
107
return primary
108
}
109
// Try to find an FQN that ends with "."+primary
110
suffix := "." + primary
111
for _, t := range tests {
112
if strings.HasSuffix(t, suffix) {
113
return t
114
}
115
}
116
return primary
117
}
118
119
// parseAlerts scans a gotestsum/go test stdout stream and extracts high-priority
120
// alerts such as data races and panics. It returns a slice of alerts in the
121
// order they were encountered.
123
>
lines := strings.Split(strings.ReplaceAll(stdout, "\r\n", "\n"), "\n")
124
>
var alerts []alert
125
>
126
>
for i := 0; i < len(lines); i++ {
127
>
line := lines[i]
128
>
129
>
if a, next, ok := tryParseDataRace(lines, i, line); ok {
130
>
alerts = append(alerts, a)
131
>
i = next
132
>
continue
133
}
135
>
alerts = append(alerts, a)
136
>
i = next
137
>
continue
138
}
140
alerts = append(alerts, a)
141
i = next
142
continue
143
}
144
}
145
147
}
148
149
// extractTestNames tries to identify Go test function names from a log block.
150
// It looks for fully-qualified names like pkg.TestXxx(...) and Go test failure lines.
152
>
var tests []string
153
>
seen := make(map[string]struct{})
154
>
for line := range strings.SplitSeq(block, "\n") {
155
>
l := strings.TrimSpace(line)
156
>
if l == "" {
157
>
continue
158
}
160
addUniqueTest(&tests, seen, name)
161
continue
162
}
164
>
addUniqueTest(&tests, seen, name)
165
>
continue
166
}
168
addUniqueTest(&tests, seen, name)
169
}
170
}
172
}
173
174
// addUniqueTest appends name to tests if not already seen.
176
>
if _, ok := seen[name]; ok {
178
>
}
180
>
*tests = append(*tests, name)
181
}
182
183
// parseTripleDashTestName parses Go test failure lines and returns the test name if present.
185
>
if !strings.HasPrefix(line, goTestFailLinePrefix) {
187
>
}
189
>
name, _, _ = strings.Cut(name, " ")
190
>
if !strings.HasPrefix(name, "Test") {
191
return "", false
192
}
194
}
195
196
// parseFullyQualifiedTestName extracts names like "pkg/path.TestName" from a line.
198
>
idx := strings.Index(line, ".Test")
199
>
if idx < 0 {
200
>
return "", false
201
>
}
202
// Include the package/path qualifier preceding ".Test"
204
>
if sp := strings.LastIndex(line[:idx], " "); sp >= 0 {
205
start = sp + 1
206
}
208
>
return line[start : idx+p], true
209
>
}
210
return "", false
211
}
212
213
// parsePlainTestName extracts a leading "TestName(" form.
215
>
if !strings.HasPrefix(line, "Test") || !strings.Contains(line, "(") {
216
>
return "", false
217
>
}
218
name := line
219
if p := strings.Index(name, "("); p > 0 {
220
name = name[:p]
221
}
222
return name, true
223
}
224
225
// tryParseDataRace parses a data race alert at position i if present.
227
>
if !strings.HasPrefix(line, "WARNING: DATA RACE") {
228
>
return alert{}, i, false
229
>
}
230
>
start := findRaceBlockStart(lines, i)
231
>
// Merge contiguous race-report sections into a single alert. The Go race
232
>
// detector may emit multiple "WARNING: DATA RACE" blocks back-to-back,
233
>
// each wrapped by a line of ==================. Treat adjacent sections as
234
>
// a single logical alert until we either hit a test boundary or a race
235
>
// boundary that is not followed by another race section.
236
>
block, end := collectBlock(lines, start, func(curLine string, idx, start int) bool {
237
>
// Stop at PASS/FAIL boundaries always.
238
>
if isTestResultBoundary(curLine) {
239
return true
240
}
241
// If we hit a race boundary after we've started, only stop if the next
242
// non-current line does not continue the race report.
244
>
if idx+1 < len(lines) {
245
>
next := strings.TrimSpace(lines[idx+1])
246
>
if isRaceBoundary(next) || strings.HasPrefix(next, "WARNING: DATA RACE") {
247
>
return false
248
>
}
249
}
251
}
253
})
255
>
Type: failureTypeDataRace,
256
>
Summary: "Data race detected",
257
>
Details: block,
258
>
Tests: extractTestNames(block),
259
>
}, end, true
260
}
261
262
// tryParsePanic parses a non-timeout panic alert at position i if present.
264
>
if !strings.HasPrefix(line, "panic: ") || strings.HasPrefix(line, "panic: test timed out after") {
265
>
return alert{}, i, false
266
>
}
267
>
block, end := collectBlock(lines, i, shouldStopOnTestBoundary)
268
>
return alert{
269
>
Type: failureTypePanic,
270
>
Summary: strings.TrimSpace(strings.TrimPrefix(line, "panic: ")),
271
>
Details: block,
272
>
Tests: extractTestNames(block),
273
>
}, end, true
274
}
275
276
// tryParseFatal parses a runtime fatal error alert at position i if present.
278
>
if !strings.HasPrefix(line, "fatal error: ") {
279
>
return alert{}, i, false
280
>
}
281
block, end := collectBlock(lines, i, shouldStopOnTestBoundary)
282
return alert{
283
Type: failureTypeFatal,
284
Summary: strings.TrimSpace(strings.TrimPrefix(line, "fatal error: ")),
285
Details: block,
286
Tests: extractTestNames(block),
287
}, end, true
288
}
289
290
// findRaceBlockStart searches upward for the race report delimiter.
292
>
start := i
293
>
for j := i - 1; j >= 0; j-- {
294
>
if isRaceBoundary(lines[j]) {
295
>
start = j
296
>
break
297
}
298
}
300
}
301
302
// collectBlock builds a block from start until the stop condition is met.
303
>
func collectBlock(lines []string, start int, stop func(line string, idx, start int) bool) (string, int) {
log.go ×27
304
>
var b strings.Builder
305
>
for j := start; j < len(lines); j++ {
306
>
b.WriteString(lines[j])
307
>
b.WriteByte('\n')
308
>
if stop(lines[j], j, start) {
309
>
return b.String(), j
310
>
}
311
}
312
return b.String(), len(lines) - 1
313
}
314
316
>
return strings.HasPrefix(strings.TrimSpace(line), "==================")
317
>
}
318
320
>
return strings.HasPrefix(line, "FAIL") || strings.HasPrefix(line, "PASS")
321
>
}
322
324
>
return isTestResultBoundary(line)
325
>
}
326
327
// parseFailedTestsFromOutput extracts failing test names from gotestsum stdout.
328
// It looks for Go test failure lines produced as tests complete, and is
329
// used when the test binary was killed externally before producing a JUnit XML.
331
>
var failed []string
332
>
seen := make(map[string]struct{})
333
>
for line := range strings.SplitSeq(strings.ReplaceAll(stdout, "\r\n", "\n"), "\n") {
334
>
line = strings.TrimSpace(line)
335
>
if !strings.HasPrefix(line, goTestFailLinePrefix) {
336
>
continue
337
}
339
>
addUniqueTest(&failed, seen, name)
340
>
}
341
}
343
}
344
345
// parseFailureDetails extracts the actionable part of a JUnit failure Data block.
347
>
lines := normalizedFailureLines(data)
348
>
349
>
// Prefer assertion blocks because they contain the useful testify failure
350
>
// detail and can be selected from the end while ignoring trailing logs.
351
>
if block, ok := findLastAssertionFailureBlock(lines); ok {
353
>
}
354
// Some failures, such as gomock errors, do not include an Error Trace.
355
// Fall back to the last Go test output block in those cases.
358
>
}
360
}
361
363
>
lines := strings.Split(strings.ReplaceAll(data, "\r\n", "\n"), "\n")
364
>
for len(lines) > 0 {
365
>
t := strings.TrimSpace(lines[len(lines)-1])
366
>
if t != "" && t != "FAIL" {
368
}
370
}
372
}
373
375
>
var failLine string
376
>
for i := len(lines) - 1; i >= 0; i-- {
378
>
if failLine == "" && strings.HasPrefix(line, goTestFailLinePrefix) {
380
>
failLine = line
381
>
continue
382
}
384
>
continue
385
}
386
387
// Include the nearest preceding line when present. For testify this is
388
// the file header; for await failures this is the attempt marker.
390
>
for prev := i - 1; prev >= 0; prev-- {
391
>
if strings.TrimSpace(lines[prev]) != "" {
392
>
start = prev
393
>
break
394
}
395
}
397
>
if failLine != "" {
399
>
}
401
}
403
}
404
406
>
sawTestLine := false
407
>
for i := start; i < len(lines); i++ {
408
>
line := strings.TrimSpace(lines[i])
409
>
if line == "" || strings.HasPrefix(line, goTestFailLinePrefix) {
411
>
}
414
>
continue
415
}
416
// Logs written after the Test line are not part of the assertion block.
419
>
}
420
}
422
}
423
425
>
for start := len(lines) - 1; start >= 0; start-- {
427
>
continue
428
}
430
>
for end < len(lines) && !isTestOutputLine(lines[end]) && lines[end] != "" {
431
>
end++
432
>
}
433
>
return start, end, true
434
}
436
}
437
438
// isTestOutputLine reports whether line is a Go test-framework output line,
439
// i.e. " file.go:N: …" — exactly 4 spaces then a non-whitespace character.
440
// Testify assertion content is indented further (8+ spaces or tabs), so this
441
// distinguishes log entries from assertion block content.
443
>
return len(line) > 4 && line[:4] == " " && line[4] != ' ' && line[4] != '\t'
444
>
}