nhyatt/go-junit-report
1
0
Fork 0
mirror of https://github.com/jstemmer/go-junit-report.git synced 2025-04-05 05:00:15 -05:00
Code Issues Projects Releases Wiki Activity

parser/gotest: parseLine now returns the events it creates

Browse Source
This commit is contained in:
Joël Stemmer 2022-08-11 23:29:28 +01:00
parent 2af321a697
commit 27ad87e370
2 changed files with 105 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
parser/gotest/gotest.go
View File

@ -143,6 +143,8 @@ func (p *Parser) parse(r *reader.LimitedLineReader) (gtr.Report, error) {
return gtr.Report{}, err return gtr.Report{}, err
} }
var evs []Event
// Lines that exceed bufio.MaxScanTokenSize are not expected to contain // Lines that exceed bufio.MaxScanTokenSize are not expected to contain
// any relevant test infrastructure output, so instead of parsing them // any relevant test infrastructure output, so instead of parsing them
// we treat them as regular output to increase performance. // we treat them as regular output to increase performance.
@ -152,9 +154,13 @@ func (p *Parser) parse(r *reader.LimitedLineReader) (gtr.Report, error) {
// turned out to be fine in almost all cases, it seemed an appropriate // turned out to be fine in almost all cases, it seemed an appropriate
// value to use to decide whether or not to attempt parsing this line. // value to use to decide whether or not to attempt parsing this line.
if len(line) > bufio.MaxScanTokenSize { if len(line) > bufio.MaxScanTokenSize {
p.output(line) evs = p.output(line)
} else { } else {
p.parseLine(line) evs = p.parseLine(line)
}
for _, ev := range evs {
p.events = append(p.events, ev)
} }
} }
return p.report(p.events), nil return p.report(p.events), nil
@ -181,76 +187,70 @@ func (p *Parser) Events() []Event {
return events return events
} }
func (p *Parser) parseLine(line string) { func (p *Parser) parseLine(line string) (events []Event) {
if strings.HasPrefix(line, "=== RUN ") { if strings.HasPrefix(line, "=== RUN ") {
p.runTest(strings.TrimSpace(line[8:])) return p.runTest(strings.TrimSpace(line[8:]))
} else if strings.HasPrefix(line, "=== PAUSE ") { } else if strings.HasPrefix(line, "=== PAUSE ") {
p.pauseTest(strings.TrimSpace(line[10:])) return p.pauseTest(strings.TrimSpace(line[10:]))
} else if strings.HasPrefix(line, "=== CONT ") { } else if strings.HasPrefix(line, "=== CONT ") {
p.contTest(strings.TrimSpace(line[9:])) return p.contTest(strings.TrimSpace(line[9:]))
} else if matches := regexEndTest.FindStringSubmatch(line); len(matches) == 5 { } else if matches := regexEndTest.FindStringSubmatch(line); len(matches) == 5 {
p.endTest(line, matches[1], matches[2], matches[3], matches[4]) return p.endTest(line, matches[1], matches[2], matches[3], matches[4])
} else if matches := regexStatus.FindStringSubmatch(line); len(matches) == 2 { } else if matches := regexStatus.FindStringSubmatch(line); len(matches) == 2 {
p.status(matches[1]) return p.status(matches[1])
} else if matches := regexSummary.FindStringSubmatch(line); len(matches) == 8 { } else if matches := regexSummary.FindStringSubmatch(line); len(matches) == 8 {
p.summary(matches[1], matches[2], matches[3], matches[4], matches[5], matches[6], matches[7]) return p.summary(matches[1], matches[2], matches[3], matches[4], matches[5], matches[6], matches[7])
} else if matches := regexCoverage.FindStringSubmatch(line); len(matches) == 3 { } else if matches := regexCoverage.FindStringSubmatch(line); len(matches) == 3 {
p.coverage(matches[1], matches[2]) return p.coverage(matches[1], matches[2])
} else if matches := regexBenchmark.FindStringSubmatch(line); len(matches) == 2 { } else if matches := regexBenchmark.FindStringSubmatch(line); len(matches) == 2 {
p.runBench(matches[1]) return p.runBench(matches[1])
} else if matches := regexBenchSummary.FindStringSubmatch(line); len(matches) == 7 { } else if matches := regexBenchSummary.FindStringSubmatch(line); len(matches) == 7 {
p.benchSummary(matches[1], matches[2], matches[3], matches[4], matches[5], matches[6]) return p.benchSummary(matches[1], matches[2], matches[3], matches[4], matches[5], matches[6])
} else if matches := regexEndBenchmark.FindStringSubmatch(line); len(matches) == 3 { } else if matches := regexEndBenchmark.FindStringSubmatch(line); len(matches) == 3 {
p.endBench(matches[1], matches[2]) return p.endBench(matches[1], matches[2])
} else if strings.HasPrefix(line, "# ") { } else if strings.HasPrefix(line, "# ") {
// TODO(jstemmer): this should just be output; we should detect build output when building report
fields := strings.Fields(strings.TrimPrefix(line, "# ")) fields := strings.Fields(strings.TrimPrefix(line, "# "))
if len(fields) == 1 || len(fields) == 2 { if len(fields) == 1 || len(fields) == 2 {
p.buildOutput(fields[0]) return p.buildOutput(fields[0])
} else {
p.output(line)
} }
} else {
p.output(line)
} }
return p.output(line)
} }
func (p *Parser) add(event Event) { func (p *Parser) runTest(name string) []Event {
p.events = append(p.events, event) return []Event{{Type: "run_test", Name: name}}
} }
func (p *Parser) runTest(name string) { func (p *Parser) pauseTest(name string) []Event {
p.add(Event{Type: "run_test", Name: name}) return []Event{{Type: "pause_test", Name: name}}
} }
func (p *Parser) pauseTest(name string) { func (p *Parser) contTest(name string) []Event {
p.add(Event{Type: "pause_test", Name: name}) return []Event{{Type: "cont_test", Name: name}}
} }
func (p *Parser) contTest(name string) { func (p *Parser) endTest(line, indent, result, name, duration string) []Event {
p.add(Event{Type: "cont_test", Name: name}) var events []Event
}
func (p *Parser) endTest(line, indent, result, name, duration string) {
if idx := strings.Index(line, fmt.Sprintf("%s--- %s:", indent, result)); idx > 0 { if idx := strings.Index(line, fmt.Sprintf("%s--- %s:", indent, result)); idx > 0 {
p.output(line[:idx]) events = append(events, p.output(line[:idx])...)
} }
_, n := stripIndent(indent) _, n := stripIndent(indent)
p.add(Event{ events = append(events, Event{
Type: "end_test", Type: "end_test",
Name: name, Name: name,
Result: result, Result: result,
Indent: n, Indent: n,
Duration: parseSeconds(duration), Duration: parseSeconds(duration),
}) })
return events
} }
func (p *Parser) status(result string) { func (p *Parser) status(result string) []Event {
p.add(Event{Type: "status", Result: result}) return []Event{{Type: "status", Result: result}}
} }
func (p *Parser) summary(result, name, duration, cached, status, covpct, packages string) { func (p *Parser) summary(result, name, duration, cached, status, covpct, packages string) []Event {
p.add(Event{ return []Event{{
Type: "summary", Type: "summary",
Result: result, Result: result,
Name: name, Name: name,
@ -258,26 +258,26 @@ func (p *Parser) summary(result, name, duration, cached, status, covpct, package
Data: strings.TrimSpace(cached + " " + status), Data: strings.TrimSpace(cached + " " + status),
CovPct: parseFloat(covpct), CovPct: parseFloat(covpct),
CovPackages: parsePackages(packages), CovPackages: parsePackages(packages),
}) }}
} }
func (p *Parser) coverage(percent, packages string) { func (p *Parser) coverage(percent, packages string) []Event {
p.add(Event{ return []Event{{
Type: "coverage", Type: "coverage",
CovPct: parseFloat(percent), CovPct: parseFloat(percent),
CovPackages: parsePackages(packages), CovPackages: parsePackages(packages),
}) }}
} }
func (p *Parser) runBench(name string) { func (p *Parser) runBench(name string) []Event {
p.add(Event{ return []Event{{
Type: "run_benchmark", Type: "run_benchmark",
Name: name, Name: name,
}) }}
} }
func (p *Parser) benchSummary(name, iterations, nsPerOp, mbPerSec, bytesPerOp, allocsPerOp string) { func (p *Parser) benchSummary(name, iterations, nsPerOp, mbPerSec, bytesPerOp, allocsPerOp string) []Event {
p.add(Event{ return []Event{{
Type: "benchmark", Type: "benchmark",
Name: name, Name: name,
Iterations: parseInt(iterations), Iterations: parseInt(iterations),
@ -285,26 +285,26 @@ func (p *Parser) benchSummary(name, iterations, nsPerOp, mbPerSec, bytesPerOp, a
MBPerSec: parseFloat(mbPerSec), MBPerSec: parseFloat(mbPerSec),
BytesPerOp: parseInt(bytesPerOp), BytesPerOp: parseInt(bytesPerOp),
AllocsPerOp: parseInt(allocsPerOp), AllocsPerOp: parseInt(allocsPerOp),
}) }}
} }
func (p *Parser) endBench(result, name string) { func (p *Parser) endBench(result, name string) []Event {
p.add(Event{ return []Event{{
Type: "end_benchmark", Type: "end_benchmark",
Name: name, Name: name,
Result: result, Result: result,
}) }}
} }
func (p *Parser) buildOutput(packageName string) { func (p *Parser) buildOutput(packageName string) []Event {
p.add(Event{ return []Event{{
Type: "build_output", Type: "build_output",
Name: packageName, Name: packageName,
}) }}
} }
func (p *Parser) output(line string) { func (p *Parser) output(line string) []Event {
p.add(Event{Type: "output", Data: line}) return []Event{{Type: "output", Data: line}}
} }
func parseSeconds(s string) time.Duration { func parseSeconds(s string) time.Duration {

110
parser/gotest/gotest_test.go
View File

@ -16,37 +16,45 @@ var (
type parseLineTest struct { type parseLineTest struct {
input string input string
events interface{} events []Event
}
func (t parseLineTest) Name() string {
var types []string
for _, e := range t.events {
types = append(types, e.Type)
}
return strings.Join(types, "-")
} }
var parseLineTests = []parseLineTest{ var parseLineTests = []parseLineTest{
{ {
"=== RUN TestOne", "=== RUN TestOne",
Event{Type: "run_test", Name: "TestOne"}, []Event{{Type: "run_test", Name: "TestOne"}},
}, },
{ {
"=== RUN TestTwo/Subtest", "=== RUN TestTwo/Subtest",
Event{Type: "run_test", Name: "TestTwo/Subtest"}, []Event{{Type: "run_test", Name: "TestTwo/Subtest"}},
}, },
{ {
"=== PAUSE TestOne", "=== PAUSE TestOne",
Event{Type: "pause_test", Name: "TestOne"}, []Event{{Type: "pause_test", Name: "TestOne"}},
}, },
{ {
"=== CONT TestOne", "=== CONT TestOne",
Event{Type: "cont_test", Name: "TestOne"}, []Event{{Type: "cont_test", Name: "TestOne"}},
}, },
{ {
"--- PASS: TestOne (12.34 seconds)", "--- PASS: TestOne (12.34 seconds)",
Event{Type: "end_test", Name: "TestOne", Result: "PASS", Duration: 12_340 * time.Millisecond}, []Event{{Type: "end_test", Name: "TestOne", Result: "PASS", Duration: 12_340 * time.Millisecond}},
}, },
{ {
" --- SKIP: TestOne/Subtest (0.00s)", " --- SKIP: TestOne/Subtest (0.00s)",
Event{Type: "end_test", Name: "TestOne/Subtest", Result: "SKIP", Indent: 1}, []Event{{Type: "end_test", Name: "TestOne/Subtest", Result: "SKIP", Indent: 1}},
}, },
{ {
" --- FAIL: TestOne/Subtest/#01 (0.35s)", " --- FAIL: TestOne/Subtest/#01 (0.35s)",
Event{Type: "end_test", Name: "TestOne/Subtest/#01", Result: "FAIL", Duration: 350 * time.Millisecond, Indent: 2}, []Event{{Type: "end_test", Name: "TestOne/Subtest/#01", Result: "FAIL", Duration: 350 * time.Millisecond, Indent: 2}},
}, },
{ {
"some text--- PASS: TestTwo (0.06 seconds)", "some text--- PASS: TestTwo (0.06 seconds)",
@ -57,157 +65,141 @@ var parseLineTests = []parseLineTest{
}, },
{ {
"PASS", "PASS",
Event{Type: "status", Result: "PASS"}, []Event{{Type: "status", Result: "PASS"}},
}, },
{ {
"FAIL", "FAIL",
Event{Type: "status", Result: "FAIL"}, []Event{{Type: "status", Result: "FAIL"}},
}, },
{ {
"SKIP", "SKIP",
Event{Type: "status", Result: "SKIP"}, []Event{{Type: "status", Result: "SKIP"}},
}, },
{ {
"ok package/name/ok 0.100s", "ok package/name/ok 0.100s",
Event{Type: "summary", Name: "package/name/ok", Result: "ok", Duration: 100 * time.Millisecond}, []Event{{Type: "summary", Name: "package/name/ok", Result: "ok", Duration: 100 * time.Millisecond}},
}, },
{ {
"FAIL package/name/failing [build failed]", "FAIL package/name/failing [build failed]",
Event{Type: "summary", Name: "package/name/failing", Result: "FAIL", Data: "[build failed]"}, []Event{{Type: "summary", Name: "package/name/failing", Result: "FAIL", Data: "[build failed]"}},
}, },
{ {
"FAIL package/other/failing [setup failed]", "FAIL package/other/failing [setup failed]",
Event{Type: "summary", Name: "package/other/failing", Result: "FAIL", Data: "[setup failed]"}, []Event{{Type: "summary", Name: "package/other/failing", Result: "FAIL", Data: "[setup failed]"}},
}, },
{ {
"ok package/other (cached)", "ok package/other (cached)",
Event{Type: "summary", Name: "package/other", Result: "ok", Data: "(cached)"}, []Event{{Type: "summary", Name: "package/other", Result: "ok", Data: "(cached)"}},
}, },
{ {
"ok package/name 0.400s coverage: 10.0% of statements", "ok package/name 0.400s coverage: 10.0% of statements",
Event{Type: "summary", Name: "package/name", Result: "ok", Duration: 400 * time.Millisecond, CovPct: 10}, []Event{{Type: "summary", Name: "package/name", Result: "ok", Duration: 400 * time.Millisecond, CovPct: 10}},
}, },
{ {
"ok package/name 4.200s coverage: 99.8% of statements in fmt, encoding/xml", "ok package/name 4.200s coverage: 99.8% of statements in fmt, encoding/xml",
Event{Type: "summary", Name: "package/name", Result: "ok", Duration: 4200 * time.Millisecond, CovPct: 99.8, CovPackages: []string{"fmt", "encoding/xml"}}, []Event{{Type: "summary", Name: "package/name", Result: "ok", Duration: 4200 * time.Millisecond, CovPct: 99.8, CovPackages: []string{"fmt", "encoding/xml"}}},
}, },
{ {
"? package/name [no test files]", "? package/name [no test files]",
Event{Type: "summary", Name: "package/name", Result: "?", Data: "[no test files]"}, []Event{{Type: "summary", Name: "package/name", Result: "?", Data: "[no test files]"}},
}, },
{ {
"ok package/name 0.001s [no tests to run]", "ok package/name 0.001s [no tests to run]",
Event{Type: "summary", Name: "package/name", Result: "ok", Duration: 1 * time.Millisecond, Data: "[no tests to run]"}, []Event{{Type: "summary", Name: "package/name", Result: "ok", Duration: 1 * time.Millisecond, Data: "[no tests to run]"}},
}, },
{ {
"ok package/name (cached) [no tests to run]", "ok package/name (cached) [no tests to run]",
Event{Type: "summary", Name: "package/name", Result: "ok", Data: "(cached) [no tests to run]"}, []Event{{Type: "summary", Name: "package/name", Result: "ok", Data: "(cached) [no tests to run]"}},
}, },
{ {
"coverage: 10% of statements", "coverage: 10% of statements",
Event{Type: "coverage", CovPct: 10}, []Event{{Type: "coverage", CovPct: 10}},
}, },
{ {
"coverage: 10% of statements in fmt, encoding/xml", "coverage: 10% of statements in fmt, encoding/xml",
Event{Type: "coverage", CovPct: 10, CovPackages: []string{"fmt", "encoding/xml"}}, []Event{{Type: "coverage", CovPct: 10, CovPackages: []string{"fmt", "encoding/xml"}}},
}, },
{ {
"coverage: 13.37% of statements", "coverage: 13.37% of statements",
Event{Type: "coverage", CovPct: 13.37}, []Event{{Type: "coverage", CovPct: 13.37}},
}, },
{ {
"coverage: 99.8% of statements in fmt, encoding/xml", "coverage: 99.8% of statements in fmt, encoding/xml",
Event{Type: "coverage", CovPct: 99.8, CovPackages: []string{"fmt", "encoding/xml"}}, []Event{{Type: "coverage", CovPct: 99.8, CovPackages: []string{"fmt", "encoding/xml"}}},
}, },
{ {
"BenchmarkOK", "BenchmarkOK",
Event{Type: "run_benchmark", Name: "BenchmarkOK"}, []Event{{Type: "run_benchmark", Name: "BenchmarkOK"}},
}, },
{ {
"BenchmarkOne-8 2000000 604 ns/op", "BenchmarkOne-8 2000000 604 ns/op",
Event{Type: "benchmark", Name: "BenchmarkOne", Iterations: 2_000_000, NsPerOp: 604}, []Event{{Type: "benchmark", Name: "BenchmarkOne", Iterations: 2_000_000, NsPerOp: 604}},
}, },
{ {
"BenchmarkTwo-16 30000 52568 ns/op 24879 B/op 494 allocs/op", "BenchmarkTwo-16 30000 52568 ns/op 24879 B/op 494 allocs/op",
Event{Type: "benchmark", Name: "BenchmarkTwo", Iterations: 30_000, NsPerOp: 52_568, BytesPerOp: 24_879, AllocsPerOp: 494}, []Event{{Type: "benchmark", Name: "BenchmarkTwo", Iterations: 30_000, NsPerOp: 52_568, BytesPerOp: 24_879, AllocsPerOp: 494}},
}, },
{ {
"BenchmarkThree 2000000000 0.26 ns/op", "BenchmarkThree 2000000000 0.26 ns/op",
Event{Type: "benchmark", Name: "BenchmarkThree", Iterations: 2_000_000_000, NsPerOp: 0.26}, []Event{{Type: "benchmark", Name: "BenchmarkThree", Iterations: 2_000_000_000, NsPerOp: 0.26}},
}, },
{ {
"BenchmarkFour-8 10000 104427 ns/op 95.76 MB/s 40629 B/op 5 allocs/op", "BenchmarkFour-8 10000 104427 ns/op 95.76 MB/s 40629 B/op 5 allocs/op",
Event{Type: "benchmark", Name: "BenchmarkFour", Iterations: 10_000, NsPerOp: 104_427, MBPerSec: 95.76, BytesPerOp: 40_629, AllocsPerOp: 5}, []Event{{Type: "benchmark", Name: "BenchmarkFour", Iterations: 10_000, NsPerOp: 104_427, MBPerSec: 95.76, BytesPerOp: 40_629, AllocsPerOp: 5}},
}, },
{ {
"--- BENCH: BenchmarkOK-8", "--- BENCH: BenchmarkOK-8",
Event{Type: "end_benchmark", Name: "BenchmarkOK", Result: "BENCH"}, []Event{{Type: "end_benchmark", Name: "BenchmarkOK", Result: "BENCH"}},
}, },
{ {
"--- FAIL: BenchmarkError", "--- FAIL: BenchmarkError",
Event{Type: "end_benchmark", Name: "BenchmarkError", Result: "FAIL"}, []Event{{Type: "end_benchmark", Name: "BenchmarkError", Result: "FAIL"}},
}, },
{ {
"--- SKIP: BenchmarkSkip", "--- SKIP: BenchmarkSkip",
Event{Type: "end_benchmark", Name: "BenchmarkSkip", Result: "SKIP"}, []Event{{Type: "end_benchmark", Name: "BenchmarkSkip", Result: "SKIP"}},
}, },
{ {
"# package/name/failing1", "# package/name/failing1",
Event{Type: "build_output", Name: "package/name/failing1"}, []Event{{Type: "build_output", Name: "package/name/failing1"}},
}, },
{ {
"# package/name/failing2 [package/name/failing2.test]", "# package/name/failing2 [package/name/failing2.test]",
Event{Type: "build_output", Name: "package/name/failing2"}, []Event{{Type: "build_output", Name: "package/name/failing2"}},
}, },
{ {
"single line stdout", "single line stdout",
Event{Type: "output", Data: "single line stdout"}, []Event{{Type: "output", Data: "single line stdout"}},
}, },
{ {
"# some more output", "# some more output",
Event{Type: "output", Data: "# some more output"}, []Event{{Type: "output", Data: "# some more output"}},
}, },
{ {
"\tfile_test.go:11: Error message", "\tfile_test.go:11: Error message",
Event{Type: "output", Data: "\tfile_test.go:11: Error message"}, []Event{{Type: "output", Data: "\tfile_test.go:11: Error message"}},
}, },
{ {
"\tfile_test.go:12: Longer", "\tfile_test.go:12: Longer",
Event{Type: "output", Data: "\tfile_test.go:12: Longer"}, []Event{{Type: "output", Data: "\tfile_test.go:12: Longer"}},
}, },
{ {
"\t\terror", "\t\terror",
Event{Type: "output", Data: "\t\terror"}, []Event{{Type: "output", Data: "\t\terror"}},
}, },
{ {
"\t\tmessage.", "\t\tmessage.",
Event{Type: "output", Data: "\t\tmessage."}, []Event{{Type: "output", Data: "\t\tmessage."}},
}, },
} }
func TestParseLine(t *testing.T) { func TestParseLine(t *testing.T) {
for i, test := range parseLineTests { for i, test := range parseLineTests {
var want []Event name := fmt.Sprintf("%d-%s", i, test.Name())
switch e := test.events.(type) {
case Event:
want = []Event{e}
case []Event:
want = e
default:
panic("invalid events type")
}
var types []string
for _, e := range want {
types = append(types, e.Type)
}
name := fmt.Sprintf("%d %s", i+1, strings.Join(types, ","))
t.Run(name, func(t *testing.T) { t.Run(name, func(t *testing.T) {
parser := NewParser() parser := NewParser()
parser.parseLine(test.input) events := parser.parseLine(test.input)
got := parser.events if diff := cmp.Diff(events, test.events); diff != "" {
if diff := cmp.Diff(want, got); diff != "" {
t.Errorf("parseLine(%q) returned unexpected events, diff (-want, +got):\n%v", test.input, diff) t.Errorf("parseLine(%q) returned unexpected events, diff (-want, +got):\n%v", test.input, diff)
} }
}) })