Vihren Atlas

Atlas › Test

TestAppendAlertsSuite

go.temporal.io/server/tools/testrunner/TestAppendAlertsSuite

Package
go.temporal.io/server/tools/testrunner
Suite / test hierarchy
TestAppendAlertsSuite
Test
TestAppendAlertsSuite
Introduced at
TestAppendAlertsSuite Test frontier
Covered ranges
19
Covered lines
76
Covered files
2

Covered source

Expand a file to inspect source; the > gutter marks covered lines.

go.temporal.io/server/tools/testrunner/junit.go 69 covered LOC · 15 ranges

Open complete file

76 }
77
78 > func generateFailure(kind failureType, data string) *junit.Result { junit.go
79 > return &junit.Result{
80 > Message: string(kind),
81 > Type: string(kind),
82 > Data: data,
83 > }
84 > }
85
86 > func (j *junitReport) write() error { junit.go
87 > f, err := os.Create(j.path)
88 > if err != nil {
89 return fmt.Errorf("failed to open junit report file: %w", err)
90 }
91 > defer f.Close() junit.go
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 }
98 > log.Printf("wrote junit report to %s", j.path) junit.go
99 > return nil
100 }
101
130 // appendAlertsSuite adds a synthetic JUnit suite summarizing high-priority alerts
131 // (data races, panics, fatals) so that CI surfaces them prominently.
132 > func (j *junitReport) appendAlertsSuite(alerts []alert) { junit.go
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.
140 > var cases []junit.Testcase junit.go
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.
162 > suite := junit.Testsuite{ junit.go
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
174 // escapes <, >, & etc., but control characters other than \t, \n, \r are not
175 // legal XML and cause parsers to reject the document.
176 > func sanitizeXML(s string) string { junit.go
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 }
184 > if r < 0x20 { junit.go
185 // 0x20 is space; lower code points are ASCII control characters.
186 return -1
187 }
188 > return r junit.go
189 }, s)
190 }
191
192 // truncateAlertDetails keeps alert payloads from bloating the JUnit artifact.
193 > func truncateAlertDetails(s string) string { junit.go
194 > if len(s) <= junitAlertDetailsMaxBytes {
195 > return s junit.go
196 > }
197 const marker = "\n... (truncated) ...\n"
198 return s[:junitAlertDetailsMaxBytes-len(marker)] + marker
201 // dedupeAlerts removes duplicate alerts (e.g., repeated across retries) based
202 // on type and details while preserving the first-seen order.
203 > func dedupeAlerts(alerts []alert) []alert { junit.go
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 {
209 continue
210 }
211 > seen[key] = struct{}{} junit.go
212 > out = append(out, a)
213 }
214 > return out junit.go
215 }
216
go.temporal.io/server/tools/testrunner/log.go 7 covered LOC · 4 ranges

Open complete file

86 // 1) Fully-qualified test name containing ".Test"
87 // 2) First detected test name
88 > func primaryTestName(tests []string) string { log.go
89 > if len(tests) == 0 {
90 return ""
91 }
92 > for _, t := range tests { log.go
93 > if strings.Contains(t, ".Test") {
94 > return t log.go
95 > }
96 }
97 > return tests[0] log.go
98 }
99