Skip to content

Commit bb8c76e

Browse files
XudongLiuHaroldXudongLiuHarold
committed
remove controller runtime dependency
Signed-off-by: Xudong Liu <[email protected]>
1 parent 58f38be commit bb8c76e

File tree

12 files changed

+327
-274
lines changed

12 files changed

+327
-274
lines changed

‎pkg/cloudprovider/vsphereparavirtual/instances.go

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -27,17 +27,17 @@ import (
2727

2828
"k8s.io/apimachinery/pkg/types"
2929
"k8s.io/apimachinery/pkg/util/wait"
30-
"sigs.k8s.io/controller-runtime/pkg/client"
3130

3231
cloudprovider "k8s.io/cloud-provider"
3332
"k8s.io/klog/v2"
3433

3534
vmopv1alpha1 "github.com/vmware-tanzu/vm-operator-api/api/v1alpha1"
35+
vmopclient "k8s.io/cloud-provider-vsphere/pkg/cloudprovider/vsphereparavirtual/vmop/clientset/versioned"
3636
"k8s.io/cloud-provider-vsphere/pkg/cloudprovider/vsphereparavirtual/vmservice"
3737
)
3838

3939
type instances struct {
40-
vmClient client.Client
40+
vmClient vmopclient.Interface
4141
namespace string
4242
}
4343

‎pkg/cloudprovider/vsphereparavirtual/instances_test.go

Lines changed: 35 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -27,10 +27,9 @@ import (
2727
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
2828
"k8s.io/apimachinery/pkg/runtime"
2929
"k8s.io/apimachinery/pkg/types"
30+
clientgotesting "k8s.io/client-go/testing"
3031
cloudprovider "k8s.io/cloud-provider"
31-
"k8s.io/cloud-provider-vsphere/pkg/util"
32-
"sigs.k8s.io/controller-runtime/pkg/client"
33-
fakeClient "sigs.k8s.io/controller-runtime/pkg/client/fake"
32+
fakevmclient "k8s.io/cloud-provider-vsphere/pkg/cloudprovider/vsphereparavirtual/vmop/clientset/versioned/fake"
3433
"sigs.k8s.io/controller-runtime/pkg/envtest"
3534
)
3635

@@ -73,7 +72,9 @@ func TestNewInstances(t *testing.T) {
7372
expectedErr error
7473
}{
7574
{
76-
name: "NewInstance: when everything is ok",
75+
name: "NewInstance: when everything is ok",
76+
// The above code is declaring a test environment variable of type `envtest.Environment` and
77+
// initializing it with an empty instance of `envtest.Environment`.
7778
testEnv: &envtest.Environment{},
7879
expectedErr: nil,
7980
},
@@ -94,16 +95,14 @@ func TestNewInstances(t *testing.T) {
9495
}
9596
}
9697

97-
func initTest(testVM *vmopv1alpha1.VirtualMachine) (*instances, *util.FakeClientWrapper) {
98-
scheme := runtime.NewScheme()
99-
_ = vmopv1alpha1.AddToScheme(scheme)
100-
fc := fakeClient.NewClientBuilder().WithScheme(scheme).WithRuntimeObjects(testVM).Build()
101-
fcw := util.NewFakeClientWrapper(fc)
98+
func initTest(testVM *vmopv1alpha1.VirtualMachine) (*instances, *fakevmclient.Clientset, error) {
99+
fc := fakevmclient.NewSimpleClientset()
102100
instance := &instances{
103-
vmClient: fcw,
101+
vmClient: fc,
104102
namespace: testClusterNameSpace,
105103
}
106-
return instance, fcw
104+
_, err := fc.VmoperatorV1alpha1().VirtualMachines(testVM.Namespace).Create(context.TODO(), testVM, metav1.CreateOptions{})
105+
return instance, fc, err
107106
}
108107

109108
func TestInstanceID(t *testing.T) {
@@ -142,7 +141,8 @@ func TestInstanceID(t *testing.T) {
142141

143142
for _, testCase := range testCases {
144143
t.Run(testCase.name, func(t *testing.T) {
145-
instance, _ := initTest(testCase.testVM)
144+
instance, _, err := initTest(testCase.testVM)
145+
assert.NoError(t, err)
146146
instanceID, err := instance.InstanceID(context.Background(), testVMName)
147147
assert.Equal(t, testCase.expectedErr, err)
148148
assert.Equal(t, testCase.expectedInstanceID, instanceID)
@@ -165,11 +165,11 @@ func TestInstanceIDThrowsErr(t *testing.T) {
165165

166166
for _, testCase := range testCases {
167167
t.Run(testCase.name, func(t *testing.T) {
168-
instance, fcw := initTest(testCase.testVM)
169-
fcw.GetFunc = func(ctx context.Context, key client.ObjectKey, obj client.Object, opts ...client.GetOption) error {
170-
return fmt.Errorf("Internal error getting VMs")
171-
}
172-
168+
instance, fc, err := initTest(testCase.testVM)
169+
assert.NoError(t, err)
170+
fc.PrependReactor("get", "virtualmachines", func(action clientgotesting.Action) (handled bool, ret runtime.Object, err error) {
171+
return true, &vmopv1alpha1.VirtualMachine{}, fmt.Errorf("Internal error getting VMs")
172+
})
173173
instanceID, err := instance.InstanceID(context.Background(), testVMName)
174174
assert.NotEqual(t, nil, err)
175175
assert.NotEqual(t, cloudprovider.InstanceNotFound, err)
@@ -201,7 +201,8 @@ func TestInstanceExistsByProviderID(t *testing.T) {
201201

202202
for _, testCase := range testCases {
203203
t.Run(testCase.name, func(t *testing.T) {
204-
instance, _ := initTest(testCase.testVM)
204+
instance, _, err := initTest(testCase.testVM)
205+
assert.NoError(t, err)
205206
providerID, err := instance.InstanceExistsByProviderID(context.Background(), testProviderID)
206207
assert.Equal(t, testCase.expectedErr, err)
207208
assert.Equal(t, testCase.expectedResult, providerID)
@@ -255,7 +256,8 @@ func TestInstanceShutdownByProviderID(t *testing.T) {
255256
testCase.testVM.Status.PowerState = vmopv1alpha1.VirtualMachinePoweredOff
256257
}
257258

258-
instance, _ := initTest(testCase.testVM)
259+
instance, _, err := initTest(testCase.testVM)
260+
assert.NoError(t, err)
259261
ret, err := instance.InstanceShutdownByProviderID(context.Background(), testProviderID)
260262
assert.Equal(t, testCase.expectedErr, err)
261263
assert.Equal(t, testCase.expectedResult, ret)
@@ -301,7 +303,8 @@ func TestNodeAddressesByProviderID(t *testing.T) {
301303

302304
for _, testCase := range testCases {
303305
t.Run(testCase.name, func(t *testing.T) {
304-
instance, _ := initTest(testCase.testVM)
306+
instance, _, err := initTest(testCase.testVM)
307+
assert.NoError(t, err)
305308
ret, err := instance.NodeAddressesByProviderID(context.Background(), testProviderID)
306309
assert.Equal(t, testCase.expectedErr, err)
307310
assert.Equal(t, testCase.expectedNodeAddress, ret)
@@ -324,11 +327,11 @@ func TestNodeAddressesByProviderIDInternalErr(t *testing.T) {
324327

325328
for _, testCase := range testCases {
326329
t.Run(testCase.name, func(t *testing.T) {
327-
instance, fcw := initTest(testCase.testVM)
328-
fcw.ListFunc = func(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error {
329-
return fmt.Errorf("Internal error listing VMs")
330-
}
331-
330+
instance, fc, err := initTest(testCase.testVM)
331+
assert.NoError(t, err)
332+
fc.PrependReactor("list", "virtualmachines", func(action clientgotesting.Action) (handled bool, ret runtime.Object, err error) {
333+
return true, &vmopv1alpha1.VirtualMachineList{}, fmt.Errorf("Internal error listing VMs")
334+
})
332335
ret, err := instance.NodeAddressesByProviderID(context.Background(), testProviderID)
333336
assert.NotEqual(t, nil, err)
334337
assert.NotEqual(t, cloudprovider.InstanceNotFound, err)
@@ -375,7 +378,8 @@ func TestNodeAddresses(t *testing.T) {
375378

376379
for _, testCase := range testCases {
377380
t.Run(testCase.name, func(t *testing.T) {
378-
instance, _ := initTest(testCase.testVM)
381+
instance, _, err := initTest(testCase.testVM)
382+
assert.NoError(t, err)
379383
ret, err := instance.NodeAddresses(context.Background(), testVMName)
380384
assert.Equal(t, testCase.expectedErr, err)
381385
assert.Equal(t, testCase.expectedNodeAddress, ret)
@@ -398,11 +402,11 @@ func TestNodeAddressesInternalErr(t *testing.T) {
398402

399403
for _, testCase := range testCases {
400404
t.Run(testCase.name, func(t *testing.T) {
401-
instance, fcw := initTest(testCase.testVM)
402-
fcw.GetFunc = func(ctx context.Context, key client.ObjectKey, obj client.Object, opts ...client.GetOption) error {
403-
return fmt.Errorf("Internal error getting VMs")
404-
}
405-
405+
instance, fc, err := initTest(testCase.testVM)
406+
assert.NoError(t, err)
407+
fc.PrependReactor("get", "virtualmachines", func(action clientgotesting.Action) (handled bool, ret runtime.Object, err error) {
408+
return true, &vmopv1alpha1.VirtualMachine{}, fmt.Errorf("Internal error getting VMs")
409+
})
406410
ret, err := instance.NodeAddresses(context.Background(), testVMName)
407411
assert.NotEqual(t, nil, err)
408412
assert.NotEqual(t, cloudprovider.InstanceNotFound, err)

‎pkg/cloudprovider/vsphereparavirtual/loadbalancer_test.go

Lines changed: 39 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -27,13 +27,12 @@ import (
2727
apierrors "k8s.io/apimachinery/pkg/api/errors"
2828
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
2929
"k8s.io/apimachinery/pkg/runtime"
30+
clientgotesting "k8s.io/client-go/testing"
3031
cloudprovider "k8s.io/cloud-provider"
31-
"sigs.k8s.io/controller-runtime/pkg/client"
32-
fakeClient "sigs.k8s.io/controller-runtime/pkg/client/fake"
32+
fakevmclient "k8s.io/cloud-provider-vsphere/pkg/cloudprovider/vsphereparavirtual/vmop/clientset/versioned/fake"
3333
"sigs.k8s.io/controller-runtime/pkg/envtest"
3434

3535
"k8s.io/cloud-provider-vsphere/pkg/cloudprovider/vsphereparavirtual/vmservice"
36-
"k8s.io/cloud-provider-vsphere/pkg/util"
3736

3837
vmopv1alpha1 "github.com/vmware-tanzu/vm-operator-api/api/v1alpha1"
3938
)
@@ -51,15 +50,13 @@ var (
5150
}
5251
)
5352

54-
func newTestLoadBalancer() (cloudprovider.LoadBalancer, *util.FakeClientWrapper) {
55-
scheme := runtime.NewScheme()
56-
_ = vmopv1alpha1.AddToScheme(scheme)
57-
fc := fakeClient.NewClientBuilder().WithScheme(scheme).Build()
58-
fcw := util.NewFakeClientWrapper(fc)
59-
vms := vmservice.NewVMService(fcw, testClusterNameSpace, &testOwnerReference)
53+
func newTestLoadBalancer() (cloudprovider.LoadBalancer, *fakevmclient.Clientset) {
54+
fc := fakevmclient.NewSimpleClientset()
55+
56+
vms := vmservice.NewVMService(fc, testClusterNameSpace, &testOwnerReference)
6057
return &loadBalancer{
6158
vmService: vms,
62-
}, fcw
59+
}, fc
6360
}
6461

6562
func TestNewLoadBalancer(t *testing.T) {
@@ -155,7 +152,7 @@ func TestUpdateLoadBalancer(t *testing.T) {
155152

156153
for _, testCase := range testCases {
157154
t.Run(testCase.name, func(t *testing.T) {
158-
lb, fcw := newTestLoadBalancer()
155+
lb, fc := newTestLoadBalancer()
159156
testK8sService := &v1.Service{
160157
ObjectMeta: metav1.ObjectMeta{
161158
Name: testK8sServiceName,
@@ -181,9 +178,9 @@ func TestUpdateLoadBalancer(t *testing.T) {
181178

182179
if testCase.expectErr {
183180
// Ensure that the client Update call returns an error on update
184-
fcw.UpdateFunc = func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
185-
return fmt.Errorf("Some undefined update error")
186-
}
181+
fc.PrependReactor("update", "virtualmachineservices", func(action clientgotesting.Action) (handled bool, ret runtime.Object, err error) {
182+
return true, &vmopv1alpha1.VirtualMachineService{}, fmt.Errorf("Some undefined update error")
183+
})
187184
err = lb.UpdateLoadBalancer(context.Background(), testClustername, testK8sService, []*v1.Node{})
188185
assert.Error(t, err)
189186
} else {
@@ -195,7 +192,7 @@ func TestUpdateLoadBalancer(t *testing.T) {
195192
}
196193

197194
func TestEnsureLoadBalancer_VMServiceExternalTrafficPolicyLocal(t *testing.T) {
198-
lb, fcw := newTestLoadBalancer()
195+
lb, fc := newTestLoadBalancer()
199196
testK8sService := &v1.Service{
200197
ObjectMeta: metav1.ObjectMeta{
201198
Name: testK8sServiceName,
@@ -205,8 +202,9 @@ func TestEnsureLoadBalancer_VMServiceExternalTrafficPolicyLocal(t *testing.T) {
205202
ExternalTrafficPolicy: v1.ServiceExternalTrafficPolicyTypeLocal,
206203
},
207204
}
208-
fcw.CreateFunc = func(ctx context.Context, obj client.Object, opts ...client.CreateOption) error {
209-
vms := &vmopv1alpha1.VirtualMachineService{
205+
206+
fc.PrependReactor("create", "virtualmachineservices", func(action clientgotesting.Action) (handled bool, ret runtime.Object, err error) {
207+
return true, &vmopv1alpha1.VirtualMachineService{
210208
Status: vmopv1alpha1.VirtualMachineServiceStatus{
211209
LoadBalancer: vmopv1alpha1.LoadBalancerStatus{
212210
Ingress: []vmopv1alpha1.LoadBalancerIngress{
@@ -216,10 +214,8 @@ func TestEnsureLoadBalancer_VMServiceExternalTrafficPolicyLocal(t *testing.T) {
216214
},
217215
},
218216
},
219-
}
220-
vms.DeepCopyInto(obj.(*vmopv1alpha1.VirtualMachineService))
221-
return nil
222-
}
217+
}, nil
218+
})
223219

224220
_, ensureErr := lb.EnsureLoadBalancer(context.Background(), testClustername, testK8sService, []*v1.Node{})
225221
assert.NoError(t, ensureErr)
@@ -231,32 +227,35 @@ func TestEnsureLoadBalancer_VMServiceExternalTrafficPolicyLocal(t *testing.T) {
231227
func TestEnsureLoadBalancer(t *testing.T) {
232228
testCases := []struct {
233229
name string
234-
createFunc func(ctx context.Context, obj client.Object, opts ...client.CreateOption) error
230+
createFunc func(action clientgotesting.Action) (handled bool, ret runtime.Object, err error)
235231
expectErr error
236232
}{
237233
{
238-
name: "when VMService is created but IP not found",
234+
name: "when VMService is created but IP not found",
235+
createFunc: func(action clientgotesting.Action) (handled bool, ret runtime.Object, err error) {
236+
return true, &vmopv1alpha1.VirtualMachineService{}, fmt.Errorf(vmservice.ErrVMServiceIPNotFound.Error())
237+
},
239238
expectErr: vmservice.ErrVMServiceIPNotFound,
240239
},
241240
{
242241
name: "when VMService creation failed",
243-
createFunc: func(ctx context.Context, obj client.Object, opts ...client.CreateOption) error {
244-
return fmt.Errorf(vmservice.ErrCreateVMService.Error())
242+
createFunc: func(action clientgotesting.Action) (handled bool, ret runtime.Object, err error) {
243+
return true, &vmopv1alpha1.VirtualMachineService{}, fmt.Errorf(vmservice.ErrCreateVMService.Error())
245244
},
246245
expectErr: vmservice.ErrCreateVMService,
247246
},
248247
}
249248

250249
for _, testCase := range testCases {
251250
t.Run(testCase.name, func(t *testing.T) {
252-
lb, fcw := newTestLoadBalancer()
251+
lb, fc := newTestLoadBalancer()
253252
testK8sService := &v1.Service{
254253
ObjectMeta: metav1.ObjectMeta{
255254
Name: testK8sServiceName,
256255
Namespace: testK8sServiceNameSpace,
257256
},
258257
}
259-
fcw.CreateFunc = testCase.createFunc
258+
fc.PrependReactor("create", "virtualmachineservices", testCase.createFunc)
260259

261260
_, ensureErr := lb.EnsureLoadBalancer(context.Background(), testClustername, testK8sService, []*v1.Node{})
262261
assert.Equal(t, ensureErr.Error(), testCase.expectErr.Error())
@@ -268,16 +267,16 @@ func TestEnsureLoadBalancer(t *testing.T) {
268267
}
269268

270269
func TestEnsureLoadBalancer_VMServiceCreatedIPFound(t *testing.T) {
271-
lb, fcw := newTestLoadBalancer()
270+
lb, fc := newTestLoadBalancer()
272271
testK8sService := &v1.Service{
273272
ObjectMeta: metav1.ObjectMeta{
274273
Name: testK8sServiceName,
275274
Namespace: testK8sServiceNameSpace,
276275
},
277276
}
278277
// Ensure that the client Create call returns a VMService with a valid IP
279-
fcw.CreateFunc = func(ctx context.Context, obj client.Object, opts ...client.CreateOption) error {
280-
vms := &vmopv1alpha1.VirtualMachineService{
278+
fc.PrependReactor("create", "virtualmachineservices", func(action clientgotesting.Action) (handled bool, ret runtime.Object, err error) {
279+
return true, &vmopv1alpha1.VirtualMachineService{
281280
Status: vmopv1alpha1.VirtualMachineServiceStatus{
282281
LoadBalancer: vmopv1alpha1.LoadBalancerStatus{
283282
Ingress: []vmopv1alpha1.LoadBalancerIngress{
@@ -308,10 +307,8 @@ func TestEnsureLoadBalancer_VMServiceCreatedIPFound(t *testing.T) {
308307
vmservice.NodeSelectorKey: vmservice.NodeRole,
309308
},
310309
},
311-
}
312-
vms.DeepCopyInto(obj.(*vmopv1alpha1.VirtualMachineService))
313-
return nil
314-
}
310+
}, nil
311+
})
315312

316313
status, ensureErr := lb.EnsureLoadBalancer(context.Background(), testClustername, testK8sService, []*v1.Node{})
317314
assert.NoError(t, ensureErr)
@@ -324,27 +321,27 @@ func TestEnsureLoadBalancer_VMServiceCreatedIPFound(t *testing.T) {
324321
func TestEnsureLoadBalancer_DeleteLB(t *testing.T) {
325322
testCases := []struct {
326323
name string
327-
deleteFunc func(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error
324+
deleteFunc func(action clientgotesting.Action) (handled bool, ret runtime.Object, err error)
328325
expectErr string
329326
}{
330327
{
331328
name: "should ignore not found error",
332-
deleteFunc: func(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error {
333-
return apierrors.NewNotFound(vmopv1alpha1.Resource("virtualmachineservice"), testClustername)
329+
deleteFunc: func(action clientgotesting.Action) (handled bool, ret runtime.Object, err error) {
330+
return true, nil, apierrors.NewNotFound(vmopv1alpha1.Resource("virtualmachineservice"), testClustername)
334331
},
335332
},
336333
{
337334
name: "should return error",
338-
deleteFunc: func(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error {
339-
return fmt.Errorf("an error occurred while deleting load balancer")
335+
deleteFunc: func(action clientgotesting.Action) (handled bool, ret runtime.Object, err error) {
336+
return true, nil, fmt.Errorf("an error occurred while deleting load balancer")
340337
},
341338
expectErr: "an error occurred while deleting load balancer",
342339
},
343340
}
344341

345342
for _, testCase := range testCases {
346343
t.Run(testCase.name, func(t *testing.T) {
347-
lb, fcw := newTestLoadBalancer()
344+
lb, fc := newTestLoadBalancer()
348345
testK8sService := &v1.Service{
349346
ObjectMeta: metav1.ObjectMeta{
350347
Name: testK8sServiceName,
@@ -356,7 +353,8 @@ func TestEnsureLoadBalancer_DeleteLB(t *testing.T) {
356353
err := lb.EnsureLoadBalancerDeleted(context.Background(), testClustername, testK8sService)
357354
assert.NoError(t, err)
358355

359-
fcw.DeleteFunc = testCase.deleteFunc
356+
fc.PrependReactor("delete", "virtualmachineservices", testCase.deleteFunc)
357+
360358
err = lb.EnsureLoadBalancerDeleted(context.Background(), "test", testK8sService)
361359
if err != nil {
362360
assert.Equal(t, err.Error(), testCase.expectErr)

0 commit comments

Comments
 (0)