1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
package outputs
import (
"encoding/json"
"fmt"
"io"
"time"
"github.com/goss-org/goss/resource"
"github.com/goss-org/goss/util"
)
// Structured is a output formatter that logs into a StructuredOutput structure
type Structured struct{}
func (r Structured) ValidOptions() []*formatOption {
return []*formatOption{
{name: foPretty},
{name: foSort},
}
}
// StructuredTestResult is an individual test result with additional human friendly summary
type StructuredTestResult struct {
resource.TestResult
SummaryLine string `json:"summary-line"`
SummaryLineCompact string `json:"summary-line-compact"`
}
// StructureTestSummary holds summary information about a test run
type StructureTestSummary struct {
TestCount int `json:"test-count"`
Failed int `json:"failed-count"`
TotalDuration time.Duration `json:"total-duration"`
}
// StructuredOutput is the full output structure for the structured output format
type StructuredOutput struct {
Results []StructuredTestResult `json:"results"`
Summary StructureTestSummary `json:"summary"`
SummaryLine string `json:"summary-line"`
}
// String represents human friendly representation of the test summary
func (s *StructureTestSummary) String() string {
return fmt.Sprintf("Count: %d, Failed: %d, Duration: %.3fs", s.TestCount, s.Failed, s.TotalDuration.Seconds())
}
// Output processes output from tests into StructuredOutput written to w as a string
func (r Structured) Output(w io.Writer, results <-chan []resource.TestResult, outConfig util.OutputConfig) (exitCode int) {
includeRaw := !util.IsValueInList(foExcludeRaw, outConfig.FormatOptions)
sort := util.IsValueInList(foSort, outConfig.FormatOptions)
results = getResults(results, sort)
result := &StructuredOutput{
Results: []StructuredTestResult{},
Summary: StructureTestSummary{},
}
var startTime time.Time
var endTime time.Time
for resultGroup := range results {
for _, testResult := range resultGroup {
if startTime.IsZero() || testResult.StartTime.Before(startTime) {
startTime = testResult.StartTime
}
if endTime.IsZero() || testResult.EndTime.After(endTime) {
endTime = testResult.EndTime
}
r := StructuredTestResult{
TestResult: testResult,
SummaryLine: humanizeResult(testResult, false, includeRaw),
SummaryLineCompact: humanizeResult(testResult, true, includeRaw),
}
if testResult.Result == resource.FAIL {
result.Summary.Failed++
}
result.Summary.TestCount++
result.Results = append(result.Results, r)
}
}
result.Summary.TotalDuration = endTime.Sub(startTime)
result.SummaryLine = result.Summary.String()
var j []byte
if util.IsValueInList(foPretty, outConfig.FormatOptions) {
j, _ = json.MarshalIndent(result, "", " ")
} else {
j, _ = json.Marshal(result)
}
fmt.Fprintln(w, string(j))
return 0
}
|
