go.temporal.io/server/tools/testrunner/junit.go
369 LOC · 200 covered · 169 uncovered · 51 ranges · 45 concepts · 20 introducers · 30 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
"encoding/xml"
5
"errors"
6
"fmt"
7
"iter"
8
"log"
9
"os"
10
"slices"
11
"strings"
12
13
"github.com/jstemmer/go-junit-report/v2/junit"
14
)
15
16
// alertsSuiteName is the JUnit suite name used for structural alerts (data
17
// races, panics, fatal errors).
18
const alertsSuiteName = "ALERTS"
19
20
const junitAlertDetailsMaxBytes = 64 * 1024
21
22
type failureType string
23
24
const (
25
// failureTypeFailed marks a failed assertion.
26
failureTypeFailed failureType = "Failed"
27
failureTypeTimeout failureType = "TIMEOUT"
28
failureTypeCrash failureType = "CRASH"
29
failureTypeDataRace failureType = "DATA RACE"
30
failureTypePanic failureType = "PANIC"
31
failureTypeFatal failureType = "FATAL"
32
)
33
34
type junitReport struct {
35
junit.Testsuites
36
path string
37
reportingErrs []error
38
}
39
41
>
f, err := os.Open(j.path)
42
>
if err != nil {
43
return fmt.Errorf("failed to open junit report file: %w", err)
44
}
46
>
47
>
decoder := xml.NewDecoder(f)
48
>
if err = decoder.Decode(&j.Testsuites); err != nil {
49
return fmt.Errorf("failed to read junit report file: %w", err)
50
}
52
}
53
54
// generateReport builds a JUnit report for failures that the runner
55
// derives itself, such as timeouts and crashes. Failure.Type stores the
56
// canonical failure type (for example TIMEOUT or CRASH), and Failure.Data is
57
// intentionally left empty.
58
>
func generateReport(names []string, suffix string, kind failureType) *junitReport {
junit.go ×1
59
>
var testcases []junit.Testcase
60
>
for _, name := range names {
61
>
testcases = append(testcases, junit.Testcase{
62
>
Name: fmt.Sprintf("%s (%s)", name, suffix),
63
>
Failure: generateFailure(kind, ""),
64
>
})
65
>
}
66
>
return &junitReport{
67
>
Testsuites: junit.Testsuites{
68
>
Suites: []junit.Testsuite{
69
>
{
70
>
Name: "suite",
71
>
Testcases: testcases,
72
>
},
73
>
},
74
>
},
75
>
}
76
}
77
79
>
return &junit.Result{
80
>
Message: string(kind),
81
>
Type: string(kind),
82
>
Data: data,
83
>
}
84
>
}
85
87
>
f, err := os.Create(j.path)
88
>
if err != nil {
89
return fmt.Errorf("failed to open junit report file: %w", err)
90
}
92
>
93
>
encoder := xml.NewEncoder(f)
94
>
encoder.Indent("", " ")
95
>
if err = encoder.Encode(j.Testsuites); err != nil {
96
return fmt.Errorf("failed to write junit report file: %w", err)
97
}
99
>
return nil
100
}
101
102
// appendSyntheticFailure adds a failure entry under a "testrunner" suite for
103
// events outside any real testcase (e.g. timeout killing gotestsum pre-write).
104
func (j *junitReport) appendSyntheticFailure(name string, kind failureType, detail string) {
105
tc := junit.Testcase{
106
Name: name,
107
Failure: generateFailure(kind, detail),
108
}
109
// Reuse an existing testrunner suite if one is already present.
110
for i := range j.Suites {
111
if j.Suites[i].Name == "testrunner" {
112
j.Suites[i].Testcases = append(j.Suites[i].Testcases, tc)
113
j.Suites[i].Failures++
114
j.Suites[i].Tests++
115
j.Tests++
116
j.Failures++
117
return
118
}
119
}
120
j.Suites = append(j.Suites, junit.Testsuite{
121
Name: "testrunner",
122
Failures: 1,
123
Tests: 1,
124
Testcases: []junit.Testcase{tc},
125
})
126
j.Tests++
127
j.Failures++
128
}
129
130
// appendAlertsSuite adds a synthetic JUnit suite summarizing high-priority alerts
131
// (data races, panics, fatals) so that CI surfaces them prominently.
133
>
// Deduplicate by type+details to avoid noisy repeats across retries.
134
>
alerts = dedupeAlerts(alerts)
135
>
if len(alerts) == 0 {
136
return
137
}
138
139
// Convert alerts to JUnit test cases.
141
>
for _, a := range alerts {
142
>
name := fmt.Sprintf("%s: %s", a.Type, a.Summary)
143
>
if p := primaryTestName(a.Tests); p != "" {
144
>
name = fmt.Sprintf("%s — in %s", name, p)
145
>
}
146
>
var sb strings.Builder
147
>
if a.Details != "" {
148
>
sb.WriteString(truncateAlertDetails(sanitizeXML(a.Details)))
149
>
sb.WriteByte('\n')
150
>
}
151
>
if len(a.Tests) > 0 {
152
>
fmt.Fprintf(&sb, "Detected in tests:\n\t%s", strings.Join(a.Tests, "\n\t"))
153
>
}
154
>
f := generateFailure(a.Type, strings.TrimRight(sb.String(), "\n"))
155
>
cases = append(cases, junit.Testcase{
156
>
Name: name,
157
>
Failure: f,
158
>
})
159
}
160
161
// Append the alerts suite to the report.
163
>
Name: alertsSuiteName,
164
>
Failures: len(cases),
165
>
Tests: len(cases),
166
>
Testcases: cases,
167
>
}
168
>
j.Suites = append(j.Suites, suite)
169
>
j.Failures += suite.Failures
170
>
j.Tests += suite.Tests
171
}
172
173
// sanitizeXML removes characters that are invalid in XML 1.0. Go's xml.Encoder
174
// escapes <, >, & etc., but control characters other than \t, \n, \r are not
175
// legal XML and cause parsers to reject the document.
177
>
return strings.Map(func(r rune) rune {
178
>
switch r {
179
>
case '\t', '\n', '\r':
180
>
return r
181
case 0xFFFE, 0xFFFF:
182
return -1 // Reserved Unicode noncharacters; disallowed in XML 1.0.
183
}
185
// 0x20 is space; lower code points are ASCII control characters.
186
return -1
187
}
189
}, s)
190
}
191
192
// truncateAlertDetails keeps alert payloads from bloating the JUnit artifact.
194
>
if len(s) <= junitAlertDetailsMaxBytes {
196
>
}
198
>
return s[:junitAlertDetailsMaxBytes-len(marker)] + marker
199
}
200
201
// dedupeAlerts removes duplicate alerts (e.g., repeated across retries) based
202
// on type and details while preserving the first-seen order.
204
>
seen := make(map[string]struct{}, len(alerts))
205
>
var out []alert
206
>
for _, a := range alerts {
207
>
key := string(a.Type) + "\n" + a.Details
208
>
if _, ok := seen[key]; ok {
210
}
212
>
out = append(out, a)
213
}
215
}
216
218
>
cases := make(map[string]struct{})
219
>
for _, suite := range j.Suites {
220
>
for _, tc := range suite.Testcases {
221
>
cases[tc.Name] = struct{}{}
222
>
}
223
}
225
}
226
228
>
var failures []string
229
>
for _, suite := range j.Suites {
230
>
if suite.Failures == 0 {
231
continue
232
}
234
>
if tc.Failure != nil {
235
>
failures = append(failures, tc.Name)
236
>
}
237
}
238
}
239
240
// Sort lexicographically
242
>
243
>
// Find leaf failures using the simplified algorithm
244
>
var leafFailures []string
245
>
for i := 0; i < len(failures)-1; i++ {
247
leafFailures = append(leafFailures, failures[i])
248
}
249
}
251
>
leafFailures = append(leafFailures, failures[len(failures)-1])
252
>
}
253
255
}
256
258
>
if len(reports) == 0 {
259
return nil, errors.New("no reports to merge")
260
}
261
263
>
var combined junit.Testsuites
264
>
combined.XMLName = reports[0].XMLName
265
>
combined.Name = reports[0].Name
266
>
267
>
for i, report := range reports {
268
>
combined.Tests += report.Tests
269
>
combined.Errors += report.Errors
270
>
combined.Failures += report.Failures
271
>
combined.Skipped += report.Skipped
272
>
combined.Disabled += report.Disabled
273
>
combined.Time += report.Time
274
>
275
>
// If the report is for a retry ...
276
>
var suffix string
277
>
if i > 0 {
279
>
if i == len(reports)-1 {
280
>
suffix += " (final)"
281
>
}
282
>
prevFailures := reports[i-1].collectTestCaseFailures()
283
>
currCases := report.collectTestCases()
284
>
285
>
var missing []string
286
>
for _, f := range prevFailures {
287
>
if _, ok := currCases[f]; !ok {
289
>
}
290
}
293
>
"expected rerun of all failures from previous attempt, missing: %v", missing))
294
>
}
295
}
296
298
>
if len(suite.Testcases) == 0 {
299
continue
300
}
301
303
>
newSuite.Name += suffix
304
>
newSuite.Testcases = make([]junit.Testcase, 0, len(suite.Testcases))
305
>
306
>
// Sort test cases by name.
307
>
slices.SortFunc(suite.Testcases, func(a, b junit.Testcase) int {
309
>
})
310
311
// Collect test cases.
313
>
testCase := suite.Testcases[j]
314
>
// Check if this is a parent test case (ie prefix of next subtest).
315
>
// Use testCase.Name+"/" to avoid matching iteration suffixes like #01.
316
>
if j != len(suite.Testcases)-1 && strings.HasPrefix(suite.Testcases[j+1].Name, testCase.Name+"/") {
318
>
continue
319
}
320
321
// Parse failure details from Failure.Data, if present.
323
>
if details := parseFailureDetails(testCase.Failure.Data); details != noFailureDetails {
325
>
}
326
}
327
328
// Failure.Type carries the canonical kind in merged JUnit.
330
>
if suite.Name == alertsSuiteName {
332
testCase.Failure.Type = testCase.Failure.Message
333
}
335
>
testCase.Failure.Type = string(failureTypeFailed)
336
>
}
337
}
339
>
newSuite.Testcases = append(newSuite.Testcases, testCase)
340
}
342
}
343
}
344
346
>
Testsuites: combined,
347
>
reportingErrs: reportingErrs,
348
>
}, nil
349
}
350
351
type node struct {
352
children map[string]node
353
}
354
356
>
return func(yield func(string, node) bool) {
357
>
for name, child := range n.children {
358
>
path := append(path, name)
359
>
if !yield(strings.Join(path, "/"), child) {
360
return
361
}
363
}
364
}
365
}
366
368
>
return n.visitor()
369
>
}