mirror of
https://github.com/jstemmer/go-junit-report.git
synced 2025-04-05 13:08:07 -05:00
079e5ce7ea
The gotest parser used a bufio.Scanner to read its input, which prevented us from reading lines larger than 64K. In order to support reading larger lines, bufio.Scanner has been replaced with bufio.Reader. The maximum line size has been increased to 4MiB and instead of returning an error when reading lines that exceed the maximum size, we truncate that line and continue parsing. Fixes #135
489 lines
14 KiB
Go
489 lines
14 KiB
Go
package gotest
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/jstemmer/go-junit-report/v2/gtr"
|
|
|
|
"github.com/google/go-cmp/cmp"
|
|
)
|
|
|
|
var (
|
|
testTimestamp = time.Date(2022, 1, 1, 0, 0, 0, 0, time.UTC)
|
|
testTimestampFunc = func() time.Time { return testTimestamp }
|
|
)
|
|
|
|
type parseLineTest struct {
|
|
input string
|
|
events interface{}
|
|
}
|
|
|
|
var parseLineTests = []parseLineTest{
|
|
{
|
|
"=== RUN TestOne",
|
|
Event{Type: "run_test", Name: "TestOne"},
|
|
},
|
|
{
|
|
"=== RUN TestTwo/Subtest",
|
|
Event{Type: "run_test", Name: "TestTwo/Subtest"},
|
|
},
|
|
{
|
|
"=== PAUSE TestOne",
|
|
Event{Type: "pause_test", Name: "TestOne"},
|
|
},
|
|
{
|
|
"=== CONT TestOne",
|
|
Event{Type: "cont_test", Name: "TestOne"},
|
|
},
|
|
{
|
|
"--- PASS: TestOne (12.34 seconds)",
|
|
Event{Type: "end_test", Name: "TestOne", Result: "PASS", Duration: 12_340 * time.Millisecond},
|
|
},
|
|
{
|
|
" --- SKIP: TestOne/Subtest (0.00s)",
|
|
Event{Type: "end_test", Name: "TestOne/Subtest", Result: "SKIP", Indent: 1},
|
|
},
|
|
{
|
|
" --- FAIL: TestOne/Subtest/#01 (0.35s)",
|
|
Event{Type: "end_test", Name: "TestOne/Subtest/#01", Result: "FAIL", Duration: 350 * time.Millisecond, Indent: 2},
|
|
},
|
|
{
|
|
"some text--- PASS: TestTwo (0.06 seconds)",
|
|
[]Event{
|
|
{Type: "output", Data: "some text"},
|
|
{Type: "end_test", Name: "TestTwo", Result: "PASS", Duration: 60 * time.Millisecond},
|
|
},
|
|
},
|
|
{
|
|
"PASS",
|
|
Event{Type: "status", Result: "PASS"},
|
|
},
|
|
{
|
|
"FAIL",
|
|
Event{Type: "status", Result: "FAIL"},
|
|
},
|
|
{
|
|
"SKIP",
|
|
Event{Type: "status", Result: "SKIP"},
|
|
},
|
|
{
|
|
"ok package/name/ok 0.100s",
|
|
Event{Type: "summary", Name: "package/name/ok", Result: "ok", Duration: 100 * time.Millisecond},
|
|
},
|
|
{
|
|
"FAIL package/name/failing [build failed]",
|
|
Event{Type: "summary", Name: "package/name/failing", Result: "FAIL", Data: "[build failed]"},
|
|
},
|
|
{
|
|
"FAIL package/other/failing [setup failed]",
|
|
Event{Type: "summary", Name: "package/other/failing", Result: "FAIL", Data: "[setup failed]"},
|
|
},
|
|
{
|
|
"ok package/other (cached)",
|
|
Event{Type: "summary", Name: "package/other", Result: "ok", Data: "(cached)"},
|
|
},
|
|
{
|
|
"ok package/name 0.400s coverage: 10.0% of statements",
|
|
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",
|
|
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]",
|
|
Event{Type: "summary", Name: "package/name", Result: "?", Data: "[no test files]"},
|
|
},
|
|
{
|
|
"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]"},
|
|
},
|
|
{
|
|
"ok package/name (cached) [no tests to run]",
|
|
Event{Type: "summary", Name: "package/name", Result: "ok", Data: "(cached) [no tests to run]"},
|
|
},
|
|
{
|
|
"coverage: 10% of statements",
|
|
Event{Type: "coverage", CovPct: 10},
|
|
},
|
|
{
|
|
"coverage: 10% of statements in fmt, encoding/xml",
|
|
Event{Type: "coverage", CovPct: 10, CovPackages: []string{"fmt", "encoding/xml"}},
|
|
},
|
|
{
|
|
"coverage: 13.37% of statements",
|
|
Event{Type: "coverage", CovPct: 13.37},
|
|
},
|
|
{
|
|
"coverage: 99.8% of statements in fmt, encoding/xml",
|
|
Event{Type: "coverage", CovPct: 99.8, CovPackages: []string{"fmt", "encoding/xml"}},
|
|
},
|
|
{
|
|
"BenchmarkOK",
|
|
Event{Type: "run_benchmark", Name: "BenchmarkOK"},
|
|
},
|
|
{
|
|
"BenchmarkOne-8 2000000 604 ns/op",
|
|
Event{Type: "benchmark", Name: "BenchmarkOne", Iterations: 2_000_000, NsPerOp: 604},
|
|
},
|
|
{
|
|
"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},
|
|
},
|
|
{
|
|
"BenchmarkThree 2000000000 0.26 ns/op",
|
|
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",
|
|
Event{Type: "benchmark", Name: "BenchmarkFour", Iterations: 10_000, NsPerOp: 104_427, MBPerSec: 95.76, BytesPerOp: 40_629, AllocsPerOp: 5},
|
|
},
|
|
{
|
|
"--- BENCH: BenchmarkOK-8",
|
|
Event{Type: "end_benchmark", Name: "BenchmarkOK", Result: "BENCH"},
|
|
},
|
|
{
|
|
"--- FAIL: BenchmarkError",
|
|
Event{Type: "end_benchmark", Name: "BenchmarkError", Result: "FAIL"},
|
|
},
|
|
{
|
|
"--- SKIP: BenchmarkSkip",
|
|
Event{Type: "end_benchmark", Name: "BenchmarkSkip", Result: "SKIP"},
|
|
},
|
|
{
|
|
"# package/name/failing1",
|
|
Event{Type: "build_output", Name: "package/name/failing1"},
|
|
},
|
|
{
|
|
"# package/name/failing2 [package/name/failing2.test]",
|
|
Event{Type: "build_output", Name: "package/name/failing2"},
|
|
},
|
|
{
|
|
"single line stdout",
|
|
Event{Type: "output", Data: "single line stdout"},
|
|
},
|
|
{
|
|
"# some more output",
|
|
Event{Type: "output", Data: "# some more output"},
|
|
},
|
|
{
|
|
"\tfile_test.go:11: Error message",
|
|
Event{Type: "output", Data: "\tfile_test.go:11: Error message"},
|
|
},
|
|
{
|
|
"\tfile_test.go:12: Longer",
|
|
Event{Type: "output", Data: "\tfile_test.go:12: Longer"},
|
|
},
|
|
{
|
|
"\t\terror",
|
|
Event{Type: "output", Data: "\t\terror"},
|
|
},
|
|
{
|
|
"\t\tmessage.",
|
|
Event{Type: "output", Data: "\t\tmessage."},
|
|
},
|
|
}
|
|
|
|
func TestParseLine(t *testing.T) {
|
|
for i, test := range parseLineTests {
|
|
var want []Event
|
|
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) {
|
|
parser := NewParser()
|
|
parser.parseLine(test.input)
|
|
got := parser.events
|
|
if diff := cmp.Diff(want, got); diff != "" {
|
|
t.Errorf("parseLine(%q) returned unexpected events, diff (-want, +got):\n%v", test.input, diff)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestParseLargeLine(t *testing.T) {
|
|
tests := []struct {
|
|
desc string
|
|
inputSize int
|
|
}{
|
|
{"small size", 128},
|
|
{"under buf size", 4095},
|
|
{"buf size", 4096},
|
|
{"multiple of buf size ", 4096 * 2},
|
|
{"not multiple of buf size", 10 * 1024},
|
|
{"bufio.MaxScanTokenSize", bufio.MaxScanTokenSize},
|
|
{"over bufio.MaxScanTokenSize", bufio.MaxScanTokenSize + 1},
|
|
{"under limit", maxLineSize - 1},
|
|
{"at limit", maxLineSize},
|
|
{"just over limit", maxLineSize + 1},
|
|
{"over limit", maxLineSize + 128},
|
|
}
|
|
|
|
createInput := func(lines ...string) *bytes.Buffer {
|
|
buf := &bytes.Buffer{}
|
|
buf.WriteString("=== RUN TestOne\n--- PASS: TestOne (0.00s)\n")
|
|
buf.WriteString(strings.Join(lines, "\n"))
|
|
return buf
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
line1 := string(make([]byte, test.inputSize))
|
|
line2 := "other line"
|
|
report, err := NewParser().Parse(createInput(line1, line2))
|
|
if err != nil {
|
|
t.Fatalf("Parse() returned error %v", err)
|
|
} else if len(report.Packages) != 1 {
|
|
t.Fatalf("Parse() returned unexpected number of packages, got %d want 1.", len(report.Packages))
|
|
} else if len(report.Packages[0].Output) != 2 {
|
|
t.Fatalf("Parse() returned unexpected number of output lines, got %d want 1.", len(report.Packages[0].Output))
|
|
}
|
|
|
|
want := line1
|
|
if len(want) > maxLineSize {
|
|
want = want[:maxLineSize]
|
|
}
|
|
if got := report.Packages[0].Output[0]; got != want {
|
|
t.Fatalf("Parse() output line1 mismatch, got len %d want len %d", len(got), len(want))
|
|
}
|
|
if report.Packages[0].Output[1] != line2 {
|
|
t.Fatalf("Parse() output line2 mismatch, got %v want %v", report.Packages[0].Output[1], line2)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestReport(t *testing.T) {
|
|
events := []Event{
|
|
{Type: "run_test", Name: "TestOne"},
|
|
{Type: "output", Data: "\tHello"},
|
|
{Type: "end_test", Name: "TestOne", Result: "PASS", Duration: 1 * time.Millisecond},
|
|
{Type: "status", Result: "PASS"},
|
|
{Type: "run_test", Name: "TestSkip"},
|
|
{Type: "end_test", Name: "TestSkip", Result: "SKIP", Duration: 1 * time.Millisecond},
|
|
{Type: "summary", Result: "ok", Name: "package/name", Duration: 1 * time.Millisecond},
|
|
{Type: "run_test", Name: "TestOne"},
|
|
{Type: "output", Data: "\tfile_test.go:10: error"},
|
|
{Type: "end_test", Name: "TestOne", Result: "FAIL", Duration: 1 * time.Millisecond},
|
|
{Type: "status", Result: "FAIL"},
|
|
{Type: "summary", Result: "FAIL", Name: "package/name2", Duration: 1 * time.Millisecond},
|
|
{Type: "output", Data: "goarch: amd64"},
|
|
{Type: "run_benchmark", Name: "BenchmarkOne"},
|
|
{Type: "benchmark", Name: "BenchmarkOne", NsPerOp: 100},
|
|
{Type: "end_benchmark", Name: "BenchmarkOne", Result: "BENCH"},
|
|
{Type: "run_benchmark", Name: "BenchmarkTwo"},
|
|
{Type: "benchmark", Name: "BenchmarkTwo"},
|
|
{Type: "end_benchmark", Name: "BenchmarkTwo", Result: "FAIL"},
|
|
{Type: "status", Result: "PASS"},
|
|
{Type: "summary", Result: "ok", Name: "package/name3", Duration: 1234 * time.Millisecond},
|
|
{Type: "build_output", Name: "package/failing1"},
|
|
{Type: "output", Data: "error message"},
|
|
{Type: "summary", Result: "FAIL", Name: "package/failing1", Data: "[build failed]"},
|
|
}
|
|
want := gtr.Report{
|
|
Packages: []gtr.Package{
|
|
{
|
|
Name: "package/name",
|
|
Duration: 1 * time.Millisecond,
|
|
Timestamp: testTimestamp,
|
|
Tests: []gtr.Test{
|
|
{
|
|
ID: 1,
|
|
Name: "TestOne",
|
|
Duration: 1 * time.Millisecond,
|
|
Result: gtr.Pass,
|
|
Output: []string{
|
|
"\tHello", // TODO: strip tabs?
|
|
},
|
|
Data: map[string]interface{}{},
|
|
},
|
|
{
|
|
ID: 2,
|
|
Name: "TestSkip",
|
|
Duration: 1 * time.Millisecond,
|
|
Result: gtr.Skip,
|
|
Data: map[string]interface{}{},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "package/name2",
|
|
Duration: 1 * time.Millisecond,
|
|
Timestamp: testTimestamp,
|
|
Tests: []gtr.Test{
|
|
{
|
|
ID: 3,
|
|
Name: "TestOne",
|
|
Duration: 1 * time.Millisecond,
|
|
Result: gtr.Fail,
|
|
Output: []string{
|
|
"\tfile_test.go:10: error",
|
|
},
|
|
Data: map[string]interface{}{},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "package/name3",
|
|
Duration: 1234 * time.Millisecond,
|
|
Timestamp: testTimestamp,
|
|
Tests: []gtr.Test{
|
|
{
|
|
ID: 4,
|
|
Name: "BenchmarkOne",
|
|
Result: gtr.Pass,
|
|
Data: map[string]interface{}{key: Benchmark{NsPerOp: 100}},
|
|
},
|
|
{
|
|
ID: 5,
|
|
Name: "BenchmarkTwo",
|
|
Result: gtr.Fail,
|
|
Data: map[string]interface{}{},
|
|
},
|
|
},
|
|
Output: []string{"goarch: amd64"},
|
|
},
|
|
{
|
|
Name: "package/failing1",
|
|
Timestamp: testTimestamp,
|
|
BuildError: gtr.Error{
|
|
ID: 6,
|
|
Name: "package/failing1",
|
|
Cause: "[build failed]",
|
|
Output: []string{"error message"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
parser := NewParser(TimestampFunc(testTimestampFunc))
|
|
got := parser.report(events)
|
|
if diff := cmp.Diff(want, got); diff != "" {
|
|
t.Errorf("FromEvents report incorrect, diff (-want, +got):\n%v", diff)
|
|
}
|
|
}
|
|
|
|
func TestSubtestModes(t *testing.T) {
|
|
events := []Event{
|
|
{Type: "run_test", Name: "TestParent"},
|
|
{Type: "output", Data: "TestParent before"},
|
|
{Type: "run_test", Name: "TestParent/Subtest#1"},
|
|
{Type: "output", Data: "Subtest#1 output"},
|
|
{Type: "run_test", Name: "TestParent/Subtest#2"},
|
|
{Type: "output", Data: "Subtest#2 output"},
|
|
{Type: "cont_test", Name: "TestParent"},
|
|
{Type: "output", Data: "TestParent after"},
|
|
{Type: "end_test", Name: "TestParent", Result: "PASS", Duration: 1 * time.Millisecond},
|
|
{Type: "end_test", Name: "TestParent/Subtest#1", Result: "FAIL", Duration: 2 * time.Millisecond},
|
|
{Type: "end_test", Name: "TestParent/Subtest#2", Result: "PASS", Duration: 3 * time.Millisecond},
|
|
{Type: "output", Data: "output"},
|
|
{Type: "summary", Result: "FAIL", Name: "package/name", Duration: 1 * time.Millisecond},
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
mode SubtestMode
|
|
want gtr.Report
|
|
}{
|
|
{
|
|
name: "ignore subtest parent results",
|
|
mode: IgnoreParentResults,
|
|
want: gtr.Report{
|
|
Packages: []gtr.Package{
|
|
{
|
|
Name: "package/name",
|
|
Duration: 1 * time.Millisecond,
|
|
Timestamp: testTimestamp,
|
|
Tests: []gtr.Test{
|
|
{
|
|
ID: 1,
|
|
Name: "TestParent",
|
|
Duration: 1 * time.Millisecond,
|
|
Result: gtr.Pass,
|
|
Output: []string{"TestParent before", "TestParent after"},
|
|
Data: map[string]interface{}{},
|
|
},
|
|
{
|
|
ID: 2,
|
|
Name: "TestParent/Subtest#1",
|
|
Duration: 2 * time.Millisecond,
|
|
Result: gtr.Fail,
|
|
Output: []string{"Subtest#1 output"},
|
|
Data: map[string]interface{}{},
|
|
},
|
|
{
|
|
ID: 3,
|
|
Name: "TestParent/Subtest#2",
|
|
Duration: 3 * time.Millisecond,
|
|
Result: gtr.Pass,
|
|
Output: []string{"Subtest#2 output"},
|
|
Data: map[string]interface{}{},
|
|
},
|
|
},
|
|
Output: []string{"output"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "exclude subtest parents",
|
|
mode: ExcludeParents,
|
|
want: gtr.Report{
|
|
Packages: []gtr.Package{
|
|
{
|
|
Name: "package/name",
|
|
Duration: 1 * time.Millisecond,
|
|
Timestamp: testTimestamp,
|
|
Tests: []gtr.Test{
|
|
{
|
|
ID: 2,
|
|
Name: "TestParent/Subtest#1",
|
|
Duration: 2 * time.Millisecond,
|
|
Result: gtr.Fail,
|
|
Output: []string{"Subtest#1 output"},
|
|
Data: map[string]interface{}{},
|
|
},
|
|
{
|
|
ID: 3,
|
|
Name: "TestParent/Subtest#2",
|
|
Duration: 3 * time.Millisecond,
|
|
Result: gtr.Pass,
|
|
Output: []string{"Subtest#2 output"},
|
|
Data: map[string]interface{}{},
|
|
},
|
|
},
|
|
Output: []string{"TestParent before", "TestParent after", "output"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
parser := NewParser(TimestampFunc(testTimestampFunc), SetSubtestMode(test.mode))
|
|
got := parser.report(events)
|
|
if diff := cmp.Diff(test.want, got); diff != "" {
|
|
t.Errorf("Invalid report created from events, diff (-want, +got):\n%v", diff)
|
|
}
|
|
})
|
|
}
|
|
}
|