Skip to content

Commit 5e633d4

Browse files
hxrshxzhxrshxz
authored
test(ddc/goosefs): migrate transform_ufs tests to ginkgo (#5564)
* test(ddc/goosefs): migrate transform_ufs tests to ginkgo Signed-off-by: Harsh <harshmastic@gmail.com> * refactor: remove redundant description fields and add Label Signed-off-by: Harsh <harshmastic@gmail.com> --------- Signed-off-by: Harsh <harshmastic@gmail.com>
1 parent 3ae72b9 commit 5e633d4

1 file changed

Lines changed: 165 additions & 147 deletions

File tree

‎pkg/ddc/goosefs/transform_ufs_test.go‎

Lines changed: 165 additions & 147 deletions
Original file line numberDiff line numberDiff line change
@@ -17,168 +17,186 @@ limitations under the License.
1717
package goosefs
1818

1919
import (
20-
"testing"
20+
. "github.com/onsi/ginkgo/v2"
21+
. "github.com/onsi/gomega"
2122

2223
datav1alpha1 "github.com/fluid-cloudnative/fluid/api/v1alpha1"
2324
v1 "k8s.io/api/core/v1"
2425
)
2526

26-
func TestTransformDatasetToVolume(t *testing.T) {
27-
var ufsPath = UFSPath{}
28-
ufsPath.Name = "test"
29-
ufsPath.HostPath = "/mnt/test"
30-
ufsPath.ContainerPath = "/underFSStorage/test"
31-
32-
var ufsPath1 = UFSPath{}
33-
ufsPath1.Name = "test"
34-
ufsPath1.HostPath = "/mnt/test"
35-
ufsPath1.ContainerPath = "/underFSStorage"
36-
37-
var tests = []struct {
38-
runtime *datav1alpha1.GooseFSRuntime
39-
dataset *datav1alpha1.Dataset
40-
value *GooseFS
41-
expect UFSPath
42-
}{
43-
{&datav1alpha1.GooseFSRuntime{}, &datav1alpha1.Dataset{
44-
Spec: datav1alpha1.DatasetSpec{
45-
Mounts: []datav1alpha1.Mount{{
46-
MountPoint: "local:///mnt/test",
47-
Name: "test",
48-
}},
49-
},
50-
}, &GooseFS{}, ufsPath},
51-
{&datav1alpha1.GooseFSRuntime{}, &datav1alpha1.Dataset{
52-
Spec: datav1alpha1.DatasetSpec{
53-
Mounts: []datav1alpha1.Mount{{
54-
MountPoint: "local:///mnt/test",
55-
Name: "test",
56-
Path: "/",
57-
}},
58-
},
59-
}, &GooseFS{}, ufsPath1},
60-
}
61-
for _, test := range tests {
62-
engine := &GooseFSEngine{}
63-
engine.transformDatasetToVolume(test.runtime, test.dataset, test.value)
64-
if test.value.UFSPaths[0].HostPath != test.expect.HostPath ||
65-
test.value.UFSPaths[0].ContainerPath != test.expect.ContainerPath {
66-
t.Errorf("expected %v, got %v", test.expect, test.value.UFSPaths[0])
27+
var _ = Describe("TransformDatasetToVolume", Label("pkg.ddc.goosefs.transform_ufs_test.go"), func() {
28+
Describe("with local mount", func() {
29+
type testCase struct {
30+
runtime *datav1alpha1.GooseFSRuntime
31+
dataset *datav1alpha1.Dataset
32+
expectPath string
33+
expectHostPath string
6734
}
68-
}
69-
}
70-
71-
func TestTransformDatasetToPVC(t *testing.T) {
72-
var ufsVolume = UFSVolume{}
73-
ufsVolume.Name = "test"
74-
ufsVolume.ContainerPath = "/underFSStorage/test"
7535

76-
var ufsVolume1 = UFSVolume{}
77-
ufsVolume1.Name = "test1"
78-
ufsVolume1.ContainerPath = "/underFSStorage"
36+
DescribeTable("should transform dataset to volume correctly",
37+
func(tc testCase) {
38+
value := &GooseFS{}
39+
engine := &GooseFSEngine{}
40+
engine.transformDatasetToVolume(tc.runtime, tc.dataset, value)
7941

80-
var ufsVolume2 = UFSVolume{}
81-
ufsVolume2.Name = "test2"
82-
ufsVolume2.SubPath = "subpath"
83-
ufsVolume2.ContainerPath = "/underFSStorage/test2"
84-
85-
var ufsVolume3 = UFSVolume{}
86-
ufsVolume3.Name = "test3"
87-
ufsVolume3.SubPath = "subpath"
88-
ufsVolume3.ContainerPath = "/underFSStorage"
89-
90-
var tests = []struct {
91-
runtime *datav1alpha1.GooseFSRuntime
92-
dataset *datav1alpha1.Dataset
93-
value *GooseFS
94-
expect UFSVolume
95-
}{
96-
{&datav1alpha1.GooseFSRuntime{}, &datav1alpha1.Dataset{
97-
Spec: datav1alpha1.DatasetSpec{
98-
Mounts: []datav1alpha1.Mount{{
99-
MountPoint: "pvc://test",
100-
Name: "test",
101-
}},
102-
},
103-
}, &GooseFS{}, ufsVolume},
104-
{&datav1alpha1.GooseFSRuntime{}, &datav1alpha1.Dataset{
105-
Spec: datav1alpha1.DatasetSpec{
106-
Mounts: []datav1alpha1.Mount{{
107-
MountPoint: "pvc://test1",
108-
Name: "test1",
109-
Path: "/",
110-
}},
111-
},
112-
}, &GooseFS{}, ufsVolume1},
113-
{&datav1alpha1.GooseFSRuntime{}, &datav1alpha1.Dataset{
114-
Spec: datav1alpha1.DatasetSpec{
115-
Mounts: []datav1alpha1.Mount{{
116-
MountPoint: "pvc://test2/subpath",
117-
Name: "test2",
118-
}},
42+
Expect(value.UFSPaths).To(HaveLen(1))
43+
Expect(value.UFSPaths[0].HostPath).To(Equal(tc.expectHostPath))
44+
Expect(value.UFSPaths[0].ContainerPath).To(Equal(tc.expectPath))
11945
},
120-
}, &GooseFS{}, ufsVolume2},
121-
{&datav1alpha1.GooseFSRuntime{}, &datav1alpha1.Dataset{
122-
Spec: datav1alpha1.DatasetSpec{
123-
Mounts: []datav1alpha1.Mount{{
124-
MountPoint: "pvc://test3/subpath",
125-
Name: "test3",
126-
Path: "/",
127-
}},
128-
},
129-
}, &GooseFS{}, ufsVolume3},
130-
}
131-
for _, test := range tests {
132-
engine := &GooseFSEngine{}
133-
engine.transformDatasetToVolume(test.runtime, test.dataset, test.value)
134-
if test.value.UFSVolumes[0].ContainerPath != test.expect.ContainerPath ||
135-
test.value.UFSVolumes[0].Name != test.expect.Name ||
136-
test.value.UFSVolumes[0].SubPath != test.expect.SubPath {
137-
t.Errorf("expected %v, got %v", test.expect, test.value)
46+
Entry("local mount without path",
47+
testCase{
48+
runtime: &datav1alpha1.GooseFSRuntime{},
49+
dataset: &datav1alpha1.Dataset{
50+
Spec: datav1alpha1.DatasetSpec{
51+
Mounts: []datav1alpha1.Mount{{
52+
MountPoint: "local:///mnt/test",
53+
Name: "test",
54+
}},
55+
},
56+
},
57+
expectPath: "/underFSStorage/test",
58+
expectHostPath: "/mnt/test",
59+
},
60+
),
61+
Entry("local mount with root path",
62+
testCase{
63+
runtime: &datav1alpha1.GooseFSRuntime{},
64+
dataset: &datav1alpha1.Dataset{
65+
Spec: datav1alpha1.DatasetSpec{
66+
Mounts: []datav1alpha1.Mount{{
67+
MountPoint: "local:///mnt/test",
68+
Name: "test",
69+
Path: "/",
70+
}},
71+
},
72+
},
73+
expectPath: "/underFSStorage",
74+
expectHostPath: "/mnt/test",
75+
},
76+
),
77+
)
78+
})
79+
80+
Describe("with PVC mount", func() {
81+
type testCase struct {
82+
runtime *datav1alpha1.GooseFSRuntime
83+
dataset *datav1alpha1.Dataset
84+
expectName string
85+
expectPath string
86+
expectSubPath string
13887
}
139-
}
140-
}
14188

142-
func TestTransformDatasetWithAffinity(t *testing.T) {
143-
var ufsPath = UFSPath{}
144-
ufsPath.Name = "test"
145-
ufsPath.HostPath = "/mnt/test"
146-
ufsPath.ContainerPath = "/opt/goosefs/underFSStorage/test"
89+
DescribeTable("should transform dataset to PVC correctly",
90+
func(tc testCase) {
91+
value := &GooseFS{}
92+
engine := &GooseFSEngine{}
93+
engine.transformDatasetToVolume(tc.runtime, tc.dataset, value)
14794

148-
var tests = []struct {
149-
runtime *datav1alpha1.GooseFSRuntime
150-
dataset *datav1alpha1.Dataset
151-
value *GooseFS
152-
expect UFSPath
153-
}{
154-
{&datav1alpha1.GooseFSRuntime{}, &datav1alpha1.Dataset{
155-
Spec: datav1alpha1.DatasetSpec{
156-
Mounts: []datav1alpha1.Mount{{
157-
MountPoint: "local:///mnt/test",
158-
Name: "test",
159-
}},
160-
NodeAffinity: &datav1alpha1.CacheableNodeAffinity{
161-
Required: &v1.NodeSelector{
162-
NodeSelectorTerms: []v1.NodeSelectorTerm{
163-
{
164-
MatchExpressions: []v1.NodeSelectorRequirement{
165-
{
166-
Operator: v1.NodeSelectorOpIn,
167-
Values: []string{"test-label-value"},
95+
Expect(value.UFSVolumes).To(HaveLen(1))
96+
Expect(value.UFSVolumes[0].Name).To(Equal(tc.expectName))
97+
Expect(value.UFSVolumes[0].ContainerPath).To(Equal(tc.expectPath))
98+
Expect(value.UFSVolumes[0].SubPath).To(Equal(tc.expectSubPath))
99+
},
100+
Entry("PVC mount without path",
101+
testCase{
102+
runtime: &datav1alpha1.GooseFSRuntime{},
103+
dataset: &datav1alpha1.Dataset{
104+
Spec: datav1alpha1.DatasetSpec{
105+
Mounts: []datav1alpha1.Mount{{
106+
MountPoint: "pvc://test",
107+
Name: "test",
108+
}},
109+
},
110+
},
111+
expectName: "test",
112+
expectPath: "/underFSStorage/test",
113+
expectSubPath: "",
114+
},
115+
),
116+
Entry("PVC mount with root path",
117+
testCase{
118+
runtime: &datav1alpha1.GooseFSRuntime{},
119+
dataset: &datav1alpha1.Dataset{
120+
Spec: datav1alpha1.DatasetSpec{
121+
Mounts: []datav1alpha1.Mount{{
122+
MountPoint: "pvc://test1",
123+
Name: "test1",
124+
Path: "/",
125+
}},
126+
},
127+
},
128+
expectName: "test1",
129+
expectPath: "/underFSStorage",
130+
expectSubPath: "",
131+
},
132+
),
133+
Entry("PVC mount with subpath",
134+
testCase{
135+
runtime: &datav1alpha1.GooseFSRuntime{},
136+
dataset: &datav1alpha1.Dataset{
137+
Spec: datav1alpha1.DatasetSpec{
138+
Mounts: []datav1alpha1.Mount{{
139+
MountPoint: "pvc://test2/subpath",
140+
Name: "test2",
141+
}},
142+
},
143+
},
144+
expectName: "test2",
145+
expectPath: "/underFSStorage/test2",
146+
expectSubPath: "subpath",
147+
},
148+
),
149+
Entry("PVC mount with subpath and root path",
150+
testCase{
151+
runtime: &datav1alpha1.GooseFSRuntime{},
152+
dataset: &datav1alpha1.Dataset{
153+
Spec: datav1alpha1.DatasetSpec{
154+
Mounts: []datav1alpha1.Mount{{
155+
MountPoint: "pvc://test3/subpath",
156+
Name: "test3",
157+
Path: "/",
158+
}},
159+
},
160+
},
161+
expectName: "test3",
162+
expectPath: "/underFSStorage",
163+
expectSubPath: "subpath",
164+
},
165+
),
166+
)
167+
})
168+
169+
Describe("with node affinity", func() {
170+
It("should set master affinity from dataset", func() {
171+
runtime := &datav1alpha1.GooseFSRuntime{}
172+
dataset := &datav1alpha1.Dataset{
173+
Spec: datav1alpha1.DatasetSpec{
174+
Mounts: []datav1alpha1.Mount{{
175+
MountPoint: "local:///mnt/test",
176+
Name: "test",
177+
}},
178+
NodeAffinity: &datav1alpha1.CacheableNodeAffinity{
179+
Required: &v1.NodeSelector{
180+
NodeSelectorTerms: []v1.NodeSelectorTerm{
181+
{
182+
MatchExpressions: []v1.NodeSelectorRequirement{
183+
{
184+
Operator: v1.NodeSelectorOpIn,
185+
Values: []string{"test-label-value"},
186+
},
168187
},
169188
},
170189
},
171190
},
172191
},
173192
},
174-
},
175-
}, &GooseFS{}, ufsPath},
176-
}
177-
for _, test := range tests {
178-
engine := &GooseFSEngine{}
179-
engine.transformDatasetToVolume(test.runtime, test.dataset, test.value)
180-
if test.value.Master.Affinity.NodeAffinity == nil {
181-
t.Error("The master affinity is nil")
182-
}
183-
}
184-
}
193+
}
194+
value := &GooseFS{}
195+
196+
engine := &GooseFSEngine{}
197+
engine.transformDatasetToVolume(runtime, dataset, value)
198+
199+
Expect(value.Master.Affinity.NodeAffinity).NotTo(BeNil())
200+
})
201+
})
202+
})

0 commit comments

Comments
 (0)