mirror of
https://github.com/jstemmer/go-junit-report.git
synced 2025-04-04 20:50:14 -05:00
85f2715ac9
The JSONEventReader implements reading lines with metadata and replaces the gotest.jsonReader struct.
123 lines
3.0 KiB
Go
123 lines
3.0 KiB
Go
package reader
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"encoding/json"
|
|
"io"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// LineReader is an interface to read lines with optional Metadata.
|
|
type LineReader interface {
|
|
ReadLine() (string, *Metadata, error)
|
|
}
|
|
|
|
// Metadata contains metadata that belongs to a line.
|
|
type Metadata struct {
|
|
Package string
|
|
}
|
|
|
|
// LimitedLineReader reads lines from an io.Reader object with a configurable
|
|
// line size limit. Lines exceeding the limit will be truncated, but read
|
|
// completely from the underlying io.Reader.
|
|
type LimitedLineReader struct {
|
|
r *bufio.Reader
|
|
limit int
|
|
}
|
|
|
|
var _ LineReader = &LimitedLineReader{}
|
|
|
|
// NewLimitedLineReader returns a LimitedLineReader to read lines from r with a
|
|
// maximum line size of limit.
|
|
func NewLimitedLineReader(r io.Reader, limit int) *LimitedLineReader {
|
|
return &LimitedLineReader{r: bufio.NewReader(r), limit: limit}
|
|
}
|
|
|
|
// ReadLine returns the next line from the underlying reader. The length of the
|
|
// line will not exceed the configured limit. ReadLine either returns a line or
|
|
// it returns an error, never both.
|
|
func (r *LimitedLineReader) ReadLine() (string, *Metadata, error) {
|
|
line, isPrefix, err := r.r.ReadLine()
|
|
if err != nil {
|
|
return "", nil, err
|
|
}
|
|
|
|
if !isPrefix {
|
|
return string(line), nil, nil
|
|
}
|
|
|
|
// Line is incomplete, keep reading until we reach the end of the line.
|
|
var buf bytes.Buffer
|
|
buf.Write(line) // ignore err, always nil
|
|
for isPrefix {
|
|
line, isPrefix, err = r.r.ReadLine()
|
|
if err != nil {
|
|
return "", nil, err
|
|
}
|
|
|
|
if buf.Len() >= r.limit {
|
|
// Stop writing to buf if we exceed the limit. We continue reading
|
|
// however to make sure we consume the entire line.
|
|
continue
|
|
}
|
|
|
|
buf.Write(line) // ignore err, always nil
|
|
}
|
|
|
|
if buf.Len() > r.limit {
|
|
buf.Truncate(r.limit)
|
|
}
|
|
return buf.String(), nil, nil
|
|
}
|
|
|
|
// Event represents a JSON event emitted by `go test -json`.
|
|
type Event struct {
|
|
Time time.Time
|
|
Action string
|
|
Package string
|
|
Test string
|
|
Elapsed float64 // seconds
|
|
Output string
|
|
}
|
|
|
|
// JSONEventReader reads JSON events from an io.Reader object.
|
|
type JSONEventReader struct {
|
|
r *LimitedLineReader
|
|
}
|
|
|
|
var _ LineReader = &JSONEventReader{}
|
|
|
|
// jsonLineLimit is the maximum size of a single JSON line emitted by `go test
|
|
// -json`.
|
|
const jsonLineLimit = 64 * 1024
|
|
|
|
// NewJSONEventReader returns a JSONEventReader to read the data in JSON
|
|
// events from r.
|
|
func NewJSONEventReader(r io.Reader) *JSONEventReader {
|
|
return &JSONEventReader{NewLimitedLineReader(r, jsonLineLimit)}
|
|
}
|
|
|
|
// ReadLine returns the next line from the underlying reader.
|
|
func (r *JSONEventReader) ReadLine() (string, *Metadata, error) {
|
|
for {
|
|
line, _, err := r.r.ReadLine()
|
|
if err != nil {
|
|
return "", nil, err
|
|
}
|
|
if len(line) == 0 || line[0] != '{' {
|
|
return line, nil, nil
|
|
}
|
|
event := &Event{}
|
|
if err := json.Unmarshal([]byte(line), event); err != nil {
|
|
return "", nil, err
|
|
}
|
|
if event.Output == "" {
|
|
// Skip events without output
|
|
continue
|
|
}
|
|
return strings.TrimSuffix(event.Output, "\n"), &Metadata{Package: event.Package}, nil
|
|
}
|
|
}
|