From 6026e8f15e0d926c1bbcedf57bd4c9ad082a0b89 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jo=C3=ABl=20Stemmer?= <stemmertech@gmail.com>
Date: Sat, 28 Apr 2018 17:40:06 +0100
Subject: [PATCH] parser/gotest: Parse package coverage

---
 pkg/parser/gotest/gotest.go      | 57 ++++++++++++++++++--------------
 pkg/parser/gotest/gotest_test.go | 28 +++++++++++++---
 2 files changed, 56 insertions(+), 29 deletions(-)

diff --git a/pkg/parser/gotest/gotest.go b/pkg/parser/gotest/gotest.go
index 8f90384..1c730c2 100644
--- a/pkg/parser/gotest/gotest.go
+++ b/pkg/parser/gotest/gotest.go
@@ -13,14 +13,14 @@ import (
 type Event struct {
 	Type string
 
-	Id       int
-	Name     string
-	Result   string
-	Duration time.Duration
-	Data     string
-	Indent   int
-	CovPct   float64
-	Hints    map[string]string
+	Id          int
+	Name        string
+	Result      string
+	Duration    time.Duration
+	Data        string
+	Indent      int
+	CovPct      float64
+	CovPackages []string
 }
 
 var (
@@ -28,8 +28,8 @@ var (
 	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.+)?)?$`)
-	regexCoverage = regexp.MustCompile(`^coverage:\s+(\d+|\d+\.\d+)%\s+of\s+statements(?:\sin\s.+)?$`)
+		`(?:\s+coverage:\s+(\d+\.\d+)%\sof\sstatements(?:\sin\s(.+))?)?$`)
+	regexCoverage = regexp.MustCompile(`^coverage:\s+(\d+|\d+\.\d+)%\s+of\s+statements(?:\sin\s(.+))?$`)
 )
 
 // Parse parses Go test output from the given io.Reader r.
@@ -61,10 +61,10 @@ func (p *parser) parseLine(line string) {
 		p.endTest(matches[1], matches[2], matches[3], matches[4])
 	} 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], matches[4], matches[5])
-	} else if matches := regexCoverage.FindStringSubmatch(line); len(matches) == 2 {
-		p.coverage(matches[1])
+	} else if matches := regexSummary.FindStringSubmatch(line); len(matches) == 7 {
+		p.summary(matches[1], matches[2], matches[3], matches[4], matches[5], matches[6])
+	} else if matches := regexCoverage.FindStringSubmatch(line); len(matches) == 3 {
+		p.coverage(matches[1], matches[2])
 	} else {
 		p.output(line)
 	}
@@ -112,21 +112,23 @@ func (p *parser) status(result string) {
 	})
 }
 
-func (p *parser) summary(result, name, duration, failure, covpct string) {
+func (p *parser) summary(result, name, duration, failure, covpct, packages string) {
 	p.add(Event{
-		Type:     "summary",
-		Result:   result,
-		Name:     name,
-		Duration: parseSeconds(duration),
-		Data:     failure,
-		CovPct:   parseCoverage(covpct),
+		Type:        "summary",
+		Result:      result,
+		Name:        name,
+		Duration:    parseSeconds(duration),
+		Data:        failure,
+		CovPct:      parseCoverage(covpct),
+		CovPackages: parsePackages(packages),
 	})
 }
 
-func (p *parser) coverage(percent string) {
+func (p *parser) coverage(percent, packages string) {
 	p.add(Event{
-		Type:   "coverage",
-		CovPct: parseCoverage(percent),
+		Type:        "coverage",
+		CovPct:      parseCoverage(percent),
+		CovPackages: parsePackages(packages),
 	})
 }
 
@@ -155,6 +157,13 @@ func parseCoverage(percent string) float64 {
 	return pct
 }
 
+func parsePackages(pkgList string) []string {
+	if len(pkgList) == 0 {
+		return nil
+	}
+	return strings.Split(pkgList, ", ")
+}
+
 func stripIndent(line string) (string, int) {
 	var indent int
 	for indent = 0; strings.HasPrefix(line, "    "); indent++ {
diff --git a/pkg/parser/gotest/gotest_test.go b/pkg/parser/gotest/gotest_test.go
index a4b1cc2..e051e06 100644
--- a/pkg/parser/gotest/gotest_test.go
+++ b/pkg/parser/gotest/gotest_test.go
@@ -272,11 +272,29 @@ var tests = []struct {
 			{Type: "output", Data: "exit status 1"},
 			{Type: "summary", Result: "FAIL", Name: "race_test", Duration: 15 * time.Millisecond},
 		}},
-	{"18-coverpkg", []Event{}},
-	{"19-pass", []Event{}},
-	{"20-parallel", []Event{}},
-	{"21-cached", []Event{}},
-	{"22-whitespace", []Event{}},
+	{"18-coverpkg",
+		[]Event{
+			{Type: "run_test", Id: 1, Name: "TestA"},
+			{Type: "end_test", Id: 1, Name: "TestA", Result: "PASS", Duration: 100 * time.Millisecond},
+			{Type: "run_test", Id: 2, Name: "TestB"},
+			{Type: "end_test", Id: 2, Name: "TestB", Result: "PASS", Duration: 300 * time.Millisecond},
+			{Type: "status", Result: "PASS"},
+			{Type: "coverage", CovPct: 10, CovPackages: []string{"fmt", "encoding/xml"}},
+			{Type: "summary", Result: "ok", Name: "package1/foo", Duration: 400 * time.Millisecond, CovPct: 10, CovPackages: []string{"fmt", "encoding/xml"}},
+			{Type: "run_test", Id: 3, Name: "TestC"},
+			{Type: "end_test", Id: 3, Name: "TestC", Result: "PASS", Duration: 4200 * time.Millisecond},
+			{Type: "status", Result: "PASS"},
+			{Type: "coverage", CovPct: 99.8, CovPackages: []string{"fmt", "encoding/xml"}},
+			{Type: "summary", Result: "ok", Name: "package2/bar", Duration: 4200 * time.Millisecond, CovPct: 99.8, CovPackages: []string{"fmt", "encoding/xml"}},
+		}},
+	{"19-pass",
+		[]Event{}},
+	{"20-parallel",
+		[]Event{}},
+	{"21-cached",
+		[]Event{}},
+	{"22-whitespace",
+		[]Event{}},
 }
 
 func TestParse(t *testing.T) {