feat(cover): support parsing go test -cover (#88)

robherley · web-flow · commit 9daaf6c318ef · 2026-05-23T11:51:13.000-04:00
* feat(cover): support parsing go test -cover

* adjust cover output

* formatting

* colspan
diff --git a/README.md b/README.md
@@ -6,6 +6,7 @@
   - [Screenshots](#screenshots)
   - [Examples](#examples)
     - [Basic](#basic)
+    - [Coverage](#coverage)
     - [Using existing test files](#using-existing-test-files)
     - [Omitting elements](#omitting-elements)
 
@@ -33,6 +34,12 @@ Powered by [Job Summaries](https://github.blog/2022-05-09-supercharging-github-a
     # Optional. Default is './...'
     testArguments:
 
+    # If true, appends `-cover` to the go test command. Skipped if testArguments
+    # already contains a -cover* flag (e.g. -coverprofile=...). Coverage is rendered
+    # as a column in the summary table.
+    # Optional. Default is 'false'
+    cover:
+
     # Parse one or more [test2json](https://pkg.go.dev/cmd/test2json) files (newline-separated) and generate a combined summary.
     # Will always exit(0) on successful test file parse.
     # fromJSONFile is accepted as an alias for a single file.
@@ -89,6 +96,28 @@ jobs:
       uses: robherley/go-test-action@v1
 ```
 
+### Coverage
+
+When `go test` is invoked with `-cover` (or `-coverprofile=...`), the action parses the per-package `coverage: X.Y% of statements` lines and appends a 📊 Coverage column to the summary table, plus the mean coverage to the header text.
+
+Use the `cover` input as a shortcut to append `-cover`:
+
+```yaml
+- name: Test
+  uses: robherley/go-test-action@v1
+  with:
+    cover: true
+```
+
+Or pass a coverage flag directly via `testArguments`:
+
+```yaml
+- name: Test
+  uses: robherley/go-test-action@v1
+  with:
+    testArguments: '-coverprofile=coverage.out ./...'
+```
+
 ### Using existing test files
 
 ```yaml
diff --git a/__tests__/events.test.ts b/__tests__/events.test.ts
@@ -73,6 +73,22 @@ describe('events', () => {
     }
   })
 
+  it('parses coverage percentage from output', () => {
+    const cases: [string, number | undefined][] = [
+      ['coverage: 87.5% of statements\\n', 87.5],
+      ['coverage: 100.0% of statements\\n', 100.0],
+      ['coverage: 0.0% of statements\\n', 0],
+      ['ok  \\tgithub.com/foo\\t0.123s\\tcoverage: 42.3% of statements\\n', 42.3],
+      ['hello world\\n', undefined],
+    ]
+
+    for (const [output, expected] of cases) {
+      const stdout = `{"Time":"2022-07-10T22:42:11.92576-04:00","Action":"output","Package":"github.com/foo","Output":"${output}"}`
+      const [event] = parseTestEvents(stdout)
+      expect(event.coverage).toEqual(expected)
+    }
+  })
+
   it('correctly indicates a cached test', () => {
     const cachedStdout =
       '{"Time":"2022-07-10T22:42:11.931552-04:00","Action":"output","Package":"github.com/robherley/go-test-example/success","Output":"ok  \\tgithub.com/robherley/go-test-example/success\\t(cached)\\n"}'
diff --git a/__tests__/inputs.test.ts b/__tests__/inputs.test.ts
@@ -30,10 +30,19 @@ describe('renderer', () => {
       moduleDirectory: '.',
       testArguments: ['./...'],
       fromJSONFiles: null,
+      cover: false,
       omit: new Set(),
     })
   })
 
+  it('parses cover', () => {
+    mockInput('cover', 'true')
+    mockGetBooleanInput.mockReturnValueOnce(true)
+    const inputs = getInputs()
+
+    expect(inputs.cover).toBe(true)
+  })
+
   it('parses moduleDirectory', () => {
     mockInput('moduleDirectory', 'foo')
     const inputs = getInputs()
diff --git a/__tests__/renderer.test.ts b/__tests__/renderer.test.ts
@@ -339,6 +339,87 @@ describe('renderer', () => {
     })
   })
 
+  describe('coverage', () => {
+    it('omits coverage column when no package has coverage', async () => {
+      const renderer = await getRenderer()
+      await renderer.writeSummary()
+      const $ = await loadSummaryHTML()
+
+      expect($('th:contains(Coverage)')).toHaveLength(0)
+      expect($.text()).not.toContain('coverage')
+    })
+
+    it('renders coverage column when at least one package has coverage', async () => {
+      const renderer = await getRenderer()
+      renderer.packageResults[1].coverage = 42.4
+      renderer.packageResults[3].coverage = 100.0
+      await renderer.writeSummary()
+      const $ = await loadSummaryHTML()
+
+      // header spans the percentage + bar columns
+      const coverageHeader = $('th:contains(📊 Coverage)')
+      expect(coverageHeader).toHaveLength(1)
+      expect(coverageHeader.attr('colspan')).toEqual('2')
+      // single decimal preserved
+      expect($('td:contains(42.4%)')).toHaveLength(1)
+      // trailing .0 dropped
+      expect($('td:contains(100%)')).toHaveLength(1)
+      expect($('td:contains(100.0%)')).toHaveLength(0)
+      // Packages without coverage get a placeholder spanning both columns
+      const placeholder = $('td:contains(—)')
+      expect(placeholder.length).toBeGreaterThan(0)
+      expect(placeholder.first().attr('colspan')).toEqual('2')
+    })
+
+    it('renders mean coverage in summary text', async () => {
+      const renderer = await getRenderer()
+      renderer.packageResults[1].coverage = 40.0
+      renderer.packageResults[3].coverage = 60.0
+      await renderer.writeSummary()
+      const $ = await loadSummaryHTML()
+
+      expect($.text()).toContain('50% coverage')
+    })
+
+    it('renders a 10-segment block progress bar', async () => {
+      const renderer = await getRenderer()
+      renderer.packageResults[1].coverage = 70.0
+      renderer.packageResults[3].coverage = 0
+      await renderer.writeSummary()
+      const $ = await loadSummaryHTML()
+
+      // 70% → 7 filled + 3 empty
+      expect($('td:contains(███████░░░)')).toHaveLength(1)
+      // 0% → 10 empty
+      expect($('td:contains(░░░░░░░░░░)')).toHaveLength(1)
+    })
+
+    it('renders the percentage and bar in separate columns', async () => {
+      const renderer = await getRenderer()
+      renderer.packageResults[1].coverage = 70.0
+      await renderer.writeSummary()
+      const $ = await loadSummaryHTML()
+
+      const row = $('tr')
+        .filter((_, el) => $(el).text().includes('70%'))
+        .first()
+      const cells = row.find('td')
+      // package, passed, failed, skipped, duration, pct, bar = 7 cells
+      expect(cells.length).toEqual(7)
+      expect($(cells[5]).text()).toContain('70%')
+      expect($(cells[6]).text()).toContain('███████░░░')
+    })
+
+    it('expands details colspan to include coverage columns', async () => {
+      const renderer = await getRenderer()
+      renderer.packageResults[1].coverage = 80.0
+      await renderer.writeSummary()
+      const $ = await loadSummaryHTML()
+
+      expect($('td[colspan="7"]').length).toBeGreaterThan(0)
+    })
+  })
+
   it('scrubs ansi from test output', async () => {
     const renderer = await getRenderer()
     const placeholder = 'no-ansi-please'
diff --git a/__tests__/results.test.ts b/__tests__/results.test.ts
@@ -75,6 +75,39 @@ describe('results', () => {
 `)
   })
 
+  it('captures coverage from package events', async () => {
+    const stdout = await getTestStdout()
+    const testEvents = parseTestEvents(stdout)
+    const packageEvent = getPackageLevelEvent(testEvents)
+
+    const coverageEvent: TestEvent = {
+      action: 'output',
+      package: packageEvent.package,
+      test: undefined as unknown as string,
+      output: 'coverage: 73.2% of statements\n',
+      isCached: false,
+      isSubtest: false,
+      isPackageLevel: true,
+      isConclusive: false,
+      coverage: 73.2,
+    }
+
+    const packageResult = new PackageResult(packageEvent, [
+      ...testEvents,
+      coverageEvent,
+    ])
+    expect(packageResult.coverage).toEqual(73.2)
+  })
+
+  it('leaves coverage undefined when not reported', async () => {
+    const stdout = await getTestStdout()
+    const testEvents = parseTestEvents(stdout)
+    const packageEvent = getPackageLevelEvent(testEvents)
+    const packageResult = new PackageResult(packageEvent, testEvents)
+
+    expect(packageResult.coverage).toBeUndefined()
+  })
+
   it('filters out any mismatched events by package', async () => {
     const stdout = await getTestStdout()
     const testEvents = parseTestEvents(stdout)
diff --git a/__tests__/runner.test.ts b/__tests__/runner.test.ts
@@ -68,6 +68,49 @@ describe('runner', () => {
     expect(spyExit).toHaveBeenCalledWith(0)
   })
 
+  it('appends -cover when cover input is set', async () => {
+    mockProcessExit()
+    vi.spyOn(Renderer.prototype, 'writeSummary').mockImplementationOnce(
+      async () => {}
+    )
+
+    process.env['INPUT_COVER'] = 'true'
+    const spy = vi.mocked(actionsExec.exec).mockImplementationOnce(async () => 0)
+
+    const runner = new Runner()
+    await runner.run()
+
+    expect(spy).toHaveBeenCalledWith(
+      'go',
+      ['test', '-json', './...', '-cover'],
+      expect.anything()
+    )
+
+    delete process.env['INPUT_COVER']
+  })
+
+  it('does not duplicate -cover when already in testArguments', async () => {
+    mockProcessExit()
+    vi.spyOn(Renderer.prototype, 'writeSummary').mockImplementationOnce(
+      async () => {}
+    )
+
+    process.env['INPUT_COVER'] = 'true'
+    process.env['INPUT_TESTARGUMENTS'] = '-coverprofile=cov.out ./...'
+    const spy = vi.mocked(actionsExec.exec).mockImplementationOnce(async () => 0)
+
+    const runner = new Runner()
+    await runner.run()
+
+    expect(spy).toHaveBeenCalledWith(
+      'go',
+      ['test', '-json', '-coverprofile=cov.out', './...'],
+      expect.anything()
+    )
+
+    delete process.env['INPUT_COVER']
+  })
+
   it('exits the process with non-zero exit code on failure', async () => {
     const spyExit = mockProcessExit()
 
diff --git a/action.yml b/action.yml
@@ -12,6 +12,10 @@ inputs:
     description: 'Arguments to `go test`, `-json` will be prepended'
     required: false
     default: './...'
+  cover:
+    description: 'Append `-cover` to the go test command (skipped if testArguments already contains a -cover* flag). Coverage is rendered as a column in the summary table.'
+    required: false
+    default: 'false'
   fromJSONFile:
     description: 'Alias for fromJSONFiles with a single file'
     required: false
diff --git a/dist/index.js b/dist/index.js
diff --git a/src/events.ts b/src/events.ts
@@ -36,8 +36,12 @@ export interface TestEvent {
   isPackageLevel: boolean
   isConclusive: boolean
   isCached: boolean
+  coverage?: number // percentage of statements covered, if reported
 }
 
+// Matches "coverage: 87.5% of statements" emitted by `go test -cover`
+const coverageRegex = /coverage:\s+(\d+(?:\.\d+)?)%\s+of\s+statements/
+
 /**
  * Convert test2json raw JSON output to TestEvent
  * @param stdout raw stdout of go test process
@@ -50,6 +54,10 @@ export function parseTestEvents(stdout: string): TestEvent[] {
   for (let line of lines) {
     try {
       const json = JSON.parse(line)
+      const coverageMatch =
+        typeof json.Output === 'string'
+          ? json.Output.match(coverageRegex)
+          : null
       events.push({
         time: json.Time && new Date(json.Time),
         action: json.Action as TestEventAction,
@@ -61,6 +69,7 @@ export function parseTestEvents(stdout: string): TestEvent[] {
         isSubtest: json.Test?.includes('/') || false, // afaik there isn't a better indicator in test2json
         isPackageLevel: typeof json.Test === 'undefined',
         isConclusive: conclusiveTestEvents.includes(json.Action),
+        coverage: coverageMatch ? parseFloat(coverageMatch[1]) : undefined,
       })
     } catch {
       core.debug(`unable to parse line: ${line}`)
diff --git a/src/inputs.ts b/src/inputs.ts
@@ -4,6 +4,7 @@ export interface Inputs {
   moduleDirectory: string
   testArguments: string[]
   fromJSONFiles: string[] | null
+  cover: boolean
   omit: Set<OmitOption>
 }
 
@@ -26,6 +27,7 @@ export const defaultInputs = (): Inputs => ({
   moduleDirectory: '.',
   testArguments: ['./...'],
   fromJSONFiles: null,
+  cover: false,
   omit: new Set(),
 })
 
@@ -70,6 +72,10 @@ export function getInputs(): Inputs {
       .filter(f => f.length > 0)
   }
 
+  if (core.getInput('cover') && core.getBooleanInput('cover')) {
+    inputs.cover = true
+  }
+
   const omit = core.getInput('omit')
   if (omit) {
     omit
diff --git a/src/renderer.ts b/src/renderer.ts
diff --git a/src/results.ts b/src/results.ts
diff --git a/src/runner.ts b/src/runner.ts
