parser/gotest: Initial version of package parser/gotest

go.mod

@@ -2,4 +2,7 @@ module github.com/jstemmer/go-junit-report/v2
 
 go 1.13
 
-require github.com/jstemmer/go-junit-report v1.0.0
+require (
+	github.com/google/go-cmp v0.5.7
+	github.com/jstemmer/go-junit-report v1.0.0
+)

go.sum

@@ -1,2 +1,6 @@
+github.com/google/go-cmp v0.5.7 h1:81/ik6ipDQS2aGcBfIN5dHDB36BwrStyeAQquSYCV4o=
+github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE=
 github.com/jstemmer/go-junit-report v1.0.0 h1:8X1gzZpR+nVQLAht+L/foqOeX2l9DTZoaIPbEQHxsds=
 github.com/jstemmer/go-junit-report v1.0.0/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

pkg/parser/gotest/gotest.go

@@ -0,0 +1,132 @@
+// Package gotest is a standard Go test output parser.
+package gotest
+
+import (
+	"bufio"
+	"io"
+	"regexp"
+	"strings"
+	"time"
+)
+
+type Event struct {
+	Type string
+
+	Id       int
+	Name     string
+	Result   string
+	Duration time.Duration
+	Data     string
+	Indent   int
+	Hints    map[string]string
+}
+
+var (
+	regexEndTest = regexp.MustCompile(`--- (PASS|FAIL|SKIP): ([^ ]+) \((\d+\.\d+)(?: seconds|s)\)`)
+	regexStatus  = regexp.MustCompile(`^(PASS|FAIL|SKIP)$`)
+	regexSummary = regexp.MustCompile(`^(ok|FAIL)\s+([^ ]+)\s+` +
+		`(?:(\d+\.\d+)s|\(cached\)|(\[\w+ failed]))` +
+		`(?:\s+coverage:\s+(\d+\.\d+)%\sof\sstatements(?:\sin\s.+)?)?$`)
+)
+
+// Parse parses Go test output from the given io.Reader r.
+func Parse(r io.Reader) ([]Event, error) {
+	p := &parser{}
+
+	s := bufio.NewScanner(r)
+	for s.Scan() {
+		p.parseLine(s.Text())
+	}
+	if s.Err() != nil {
+		return nil, s.Err()
+	}
+
+	return p.events, nil
+}
+
+type parser struct {
+	id     int
+	events []Event
+}
+
+func (p *parser) parseLine(line string) {
+	if strings.HasPrefix(line, "=== RUN ") {
+		p.runTest(line[8:])
+	} else if strings.HasPrefix(line, "=== PAUSE ") {
+	} else if strings.HasPrefix(line, "=== CONT ") {
+	} else if matches := regexEndTest.FindStringSubmatch(line); len(matches) == 4 {
+		p.endTest(matches[1], matches[2], matches[3])
+	} else if matches := regexStatus.FindStringSubmatch(line); len(matches) == 2 {
+		p.status(matches[1])
+	} else if matches := regexSummary.FindStringSubmatch(line); len(matches) == 6 {
+		p.summary(matches[1], matches[2], matches[3])
+	} else {
+		p.output(line)
+	}
+}
+
+func (p *parser) add(event Event) {
+	p.events = append(p.events, event)
+}
+
+func (p *parser) findTest(name string) int {
+	for i := len(p.events) - 1; i >= 0; i-- {
+		// TODO: should we only consider tests that haven't ended yet?
+		if p.events[i].Type == "run_test" && p.events[i].Name == name {
+			return p.events[i].Id
+		}
+	}
+	return -1
+}
+
+func (p *parser) runTest(name string) {
+	p.id += 1
+	p.add(Event{
+		Type: "run_test",
+		Id:   p.id,
+		Name: strings.TrimSpace(name),
+	})
+}
+
+func (p *parser) endTest(result, name, duration string) {
+	p.add(Event{
+		Type:     "end_test",
+		Id:       p.findTest(name),
+		Name:     name,
+		Result:   result,
+		Duration: parseSeconds(duration),
+	})
+}
+
+func (p *parser) status(result string) {
+	p.add(Event{
+		Type:   "status",
+		Result: result,
+	})
+}
+
+func (p *parser) summary(result, name, duration string) {
+	p.add(Event{
+		Type:     "summary",
+		Result:   result,
+		Name:     name,
+		Duration: parseSeconds(duration),
+	})
+}
+
+func (p *parser) output(line string) {
+	p.add(Event{
+		Type:   "output",
+		Data:   line,
+		Indent: 0, // TODO
+	})
+}
+
+func parseSeconds(s string) time.Duration {
+	if s == "" {
+		return time.Duration(0)
+	}
+	// ignore error
+	d, _ := time.ParseDuration(s + "s")
+	return d
+}

pkg/parser/gotest/gotest_test.go

@@ -0,0 +1,46 @@
+package gotest
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+const testdataRoot = "../../../testdata/"
+
+var tests = []struct {
+	in       string
+	expected []Event
+}{
+	{"01-pass.txt",
+		[]Event{
+			{Type: "run_test", Id: 1, Name: "TestZ"},
+			{Type: "end_test", Id: 1, Name: "TestZ", Result: "PASS", Duration: 60 * time.Millisecond},
+			{Type: "run_test", Id: 2, Name: "TestA"},
+			{Type: "end_test", Id: 2, Name: "TestA", Result: "PASS", Duration: 100 * time.Millisecond},
+			{Type: "status", Result: "PASS"},
+			{Type: "summary", Result: "ok", Name: "package/name", Duration: 160 * time.Millisecond},
+		}},
+}
+
+func TestParse(t *testing.T) {
+	for _, test := range tests {
+		f, err := os.Open(testdataRoot + test.in)
+		if err != nil {
+			t.Errorf("error reading %s: %v", test.in, err)
+			continue
+		}
+		actual, err := Parse(f)
+		f.Close()
+		if err != nil {
+			t.Errorf("Parse(%s) error: %v", test.in, err)
+			continue
+		}
+
+		if diff := cmp.Diff(actual, test.expected); diff != "" {
+			t.Errorf("Parse %s returned unexpected events, diff (-got, +want):\n%v", test.in, diff)
+		}
+	}
+}