/
reader_test.go
155 lines (137 loc) · 4.26 KB
/
reader_test.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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
package reader
import (
"fmt"
"io/ioutil"
"os"
"path/filepath"
"sort"
"strings"
"testing"
"github.com/spf13/afero"
"github.com/stretchr/testify/assert"
"sigs.k8s.io/yaml"
kudoapi "github.com/kudobuilder/kudo/pkg/apis/kudo/v1beta1"
"github.com/kudobuilder/kudo/pkg/kudoctl/packages"
)
func TestReadFileSystemPackage(t *testing.T) {
tests := []struct {
name string
instanceName string
path string
goldenFiles string
}{
{"zookeeper", "zk1", "../testdata/zk", "../testdata/zk-crd-golden1"},
{"zookeeper zipped", "zk2", "../testdata/zk.tgz", "../testdata/zk-crd-golden2"},
}
var fs = afero.NewOsFs()
for _, tt := range tests {
tt := tt
t.Run(fmt.Sprintf("%s-from-%s", tt.name, tt.path), func(t *testing.T) {
var err error
var got *packages.Resources
if strings.HasSuffix(tt.path, ".tgz") {
got, err = ResourcesFromTar(fs, afero.NewMemMapFs(), tt.path)
} else {
got, err = ResourcesFromDir(fs, tt.path)
}
assert.NoError(t, err, "unexpected error while reading the package")
got.Instance.ObjectMeta.Name = tt.instanceName
golden, err := loadResourcesFromPath(tt.goldenFiles)
if err != nil {
t.Errorf("Found unexpected error when loading golden files: %v", err)
}
// we need to sort here because current yaml parsing is not preserving the order of fields
// at the same time, the deep library we use for equality does not support ignoring order
sort.Slice(got.OperatorVersion.Spec.Parameters, func(i, j int) bool {
return got.OperatorVersion.Spec.Parameters[i].Name < got.OperatorVersion.Spec.Parameters[j].Name
})
sort.Slice(golden.OperatorVersion.Spec.Parameters, func(i, j int) bool {
return golden.OperatorVersion.Spec.Parameters[i].Name < golden.OperatorVersion.Spec.Parameters[j].Name
})
assert.Equal(t, golden, got)
})
}
}
func loadResourcesFromPath(goldenPath string) (*packages.Resources, error) {
isOperatorFile := func(name string) bool {
return strings.HasSuffix(name, "operator.golden")
}
isVersionFile := func(name string) bool {
return strings.HasSuffix(name, "operatorversion.golden")
}
isInstanceFile := func(name string) bool {
return strings.HasSuffix(name, "instance.golden")
}
result := &packages.Resources{}
err := filepath.Walk(goldenPath, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if path == goldenPath {
// skip the root folder, as Walk always starts there
return nil
}
bytes, err := ioutil.ReadFile(path)
if err != nil {
return err
}
switch {
case isOperatorFile(info.Name()):
var f kudoapi.Operator
if err = yaml.Unmarshal(bytes, &f); err != nil {
return fmt.Errorf("cannot unmarshal %s content: %w", info.Name(), err)
}
result.Operator = &f
case isVersionFile(info.Name()):
var fv kudoapi.OperatorVersion
if err = yaml.Unmarshal(bytes, &fv); err != nil {
return fmt.Errorf("cannot unmarshal %s content: %w", info.Name(), err)
}
result.OperatorVersion = &fv
case isInstanceFile(info.Name()):
var i kudoapi.Instance
if err = yaml.Unmarshal(bytes, &i); err != nil {
return fmt.Errorf("cannot unmarshal %s content: %w", info.Name(), err)
}
result.Instance = &i
default:
return fmt.Errorf("unexpected file in the tarball structure %s", info.Name())
}
return nil
})
if err != nil {
return nil, err
}
return result, nil
}
func Test_readParametersFile(t *testing.T) {
noParams := `
apiVersion: kudo.dev/v1beta1
parameters:
`
oneParam := `
apiVersion: kudo.dev/v1beta1
parameters:
- name: example
`
example := []packages.Parameter{{Name: "example"}}
tests := []struct {
name string
paramsYaml string
want packages.ParamsFile
wantErr bool
}{
{"no data", "", packages.ParamsFile{APIVersion: APIVersion}, false},
{"no parameters", noParams, packages.ParamsFile{APIVersion: APIVersion}, false},
{"parameters", oneParam, packages.ParamsFile{APIVersion: APIVersion, Parameters: example}, false},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
got, err := readParametersFile([]byte(tt.paramsYaml))
fmt.Printf("%s got: %v\n", tt.name, got)
assert.Equal(t, tt.wantErr, err != nil, "readParametersFile() error = %v, wantErr %v", err, tt.wantErr)
assert.Equal(t, tt.want, got)
})
}
}