/
result.go
134 lines (118 loc) · 2.91 KB
/
result.go
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
package executetest
import (
"fmt"
"github.com/google/go-cmp/cmp"
"github.com/influxdata/flux"
)
type Result struct {
Nm string
Tbls []*Table
Err error
}
// ConvertResult produces a result object from any flux.Result type.
func ConvertResult(result flux.Result) *Result {
var tbls []*Table
err := result.Tables().Do(func(tbl flux.Table) error {
t, err := ConvertTable(tbl)
if err != nil {
return err
}
tbls = append(tbls, t)
return nil
})
return &Result{
Nm: result.Name(),
Tbls: tbls,
Err: err,
}
}
func NewResult(tables []*Table) *Result {
return &Result{Tbls: tables}
}
func (r *Result) Name() string {
return r.Nm
}
func (r *Result) Tables() flux.TableIterator {
return &TableIterator{
r.Tbls,
r.Err,
}
}
func (r *Result) Normalize() {
NormalizeTables(r.Tbls)
}
type TableIterator struct {
Tables []*Table
Err error
}
func (ti *TableIterator) Do(f func(flux.Table) error) error {
if ti.Err != nil {
return ti.Err
}
for _, t := range ti.Tables {
if err := f(t); err != nil {
return err
}
}
return nil
}
// EqualResults compares two lists of Flux Results for equality
func EqualResults(want, got []flux.Result) error {
wantTables := convertResults(want)
gotTables := convertResults(got)
if diff := cmp.Diff(wantTables, gotTables, defaultFloatOptions); diff != "" {
return fmt.Errorf("unexpected iterator results; -want/+got\n%s", diff)
}
return nil
}
func convertResults(rs []flux.Result) []*Result {
tables := make([]*Result, len(rs))
for i, r := range rs {
tables[i] = ConvertResult(r)
}
return tables
}
// EqualResultIterators compares two ResultIterators for equality
func EqualResultIterators(want, got flux.ResultIterator) error {
wantResults, wantErr := readAllIterator(want)
gotResults, gotErr := readAllIterator(got)
if diff := cmp.Diff(wantResults, gotResults, defaultFloatOptions); diff != "" {
return fmt.Errorf("unexpected iterator results; -want/+got\n%s", diff)
}
if wantErr == nil && gotErr == nil {
return nil
}
if wantErr == nil || gotErr == nil || wantErr.Error() != gotErr.Error() {
return fmt.Errorf("unexpected errors got %v; want: %v", gotErr, wantErr)
}
return nil
}
func readAllIterator(iter flux.ResultIterator) ([][]*Table, error) {
results := [][]*Table{}
for iter.More() {
tables := []*Table{}
err := iter.Next().Tables().Do(func(tbl flux.Table) error {
t, err := ConvertTable(tbl)
if err != nil {
return fmt.Errorf("cannot convert table: %v", err)
}
tables = append(tables, t)
return nil
})
if err != nil {
return nil, err
}
NormalizeTables(tables)
results = append(results, tables)
}
return results, iter.Err()
}
// EqualResult compares to results for equality
func EqualResult(w, g flux.Result) error {
want := ConvertResult(w)
got := ConvertResult(g)
if diff := cmp.Diff(want, got, defaultFloatOptions); diff != "" {
return fmt.Errorf("unexpected tables -want/+got\n%s", diff)
}
return nil
}