Skip to content

Commit 8794adb

Browse files
Shilpa-GokulShilpa-Gokul
committed
Cover UT for getNetwork,isDHCPServerActive,checkDHCPServerStatus, createDHCPServer functions
1 parent b23d800 commit 8794adb

File tree

1 file changed

+284
-26
lines changed

1 file changed

+284
-26
lines changed

‎cloud/scope/powervs_cluster_test.go

Lines changed: 284 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -158,6 +158,286 @@ func TestNewPowerVSClusterScope(t *testing.T) {
158158
}
159159
}
160160

161+
func TestGetNetwork(t *testing.T) {
162+
var (
163+
mockPowerVS *mockP.MockPowerVS
164+
mockCtrl *gomock.Controller
165+
)
166+
167+
setup := func(t *testing.T) {
168+
t.Helper()
169+
mockCtrl = gomock.NewController(t)
170+
mockPowerVS = mockP.NewMockPowerVS(mockCtrl)
171+
}
172+
teardown := func() {
173+
mockCtrl.Finish()
174+
}
175+
t.Run("When network ID is not nil and GetNetworkByID is success", func(t *testing.T) {
176+
g := NewWithT(t)
177+
setup(t)
178+
t.Cleanup(teardown)
179+
180+
network := &models.Network{NetworkID: ptr.To("networkID")}
181+
clusterScopeParams := getPowerVSClusterScopeParams()
182+
clusterScopeParams.PowerVSClientFactory = func() (powervs.PowerVS, error) {
183+
mockPowerVS.EXPECT().GetNetworkByID(gomock.Any()).Return(network, nil)
184+
return mockPowerVS, nil
185+
}
186+
187+
clusterScopeParams.IBMPowerVSCluster.Spec.Network = infrav1beta2.IBMPowerVSResourceReference{ID: ptr.To("networkID")}
188+
clusterScope, _ := NewPowerVSClusterScope(clusterScopeParams)
189+
190+
networkID, err := clusterScope.getNetwork()
191+
g.Expect(err).To(BeNil())
192+
g.Expect(networkID).To(Equal(network.NetworkID))
193+
})
194+
t.Run("When network ID is nil and DHCPServer is not empty", func(t *testing.T) {
195+
g := NewWithT(t)
196+
setup(t)
197+
t.Cleanup(teardown)
198+
199+
clusterScopeParams := getPowerVSClusterScopeParams()
200+
clusterScopeParams.IBMPowerVSCluster.Spec.DHCPServer.Name = ptr.To("server1")
201+
networkName := fmt.Sprintf("DHCPSERVER%s_Private", *clusterScopeParams.IBMPowerVSCluster.Spec.DHCPServer.Name)
202+
network := &models.NetworkReference{NetworkID: ptr.To("networkID"), Name: &networkName}
203+
clusterScopeParams.PowerVSClientFactory = func() (powervs.PowerVS, error) {
204+
mockPowerVS.EXPECT().GetNetworkByName(*network.Name).Return(network, nil)
205+
return mockPowerVS, nil
206+
}
207+
208+
clusterScope, _ := NewPowerVSClusterScope(clusterScopeParams)
209+
210+
networkID, err := clusterScope.getNetwork()
211+
g.Expect(err).To(BeNil())
212+
g.Expect(networkID).To(Equal(network.NetworkID))
213+
})
214+
215+
t.Run("When network ID is nil and DHCPServer is also empty", func(t *testing.T) {
216+
g := NewWithT(t)
217+
setup(t)
218+
t.Cleanup(teardown)
219+
220+
clusterScopeParams := getPowerVSClusterScopeParams()
221+
clusterScopeParams.IBMPowerVSCluster.Spec.Network = infrav1beta2.IBMPowerVSResourceReference{}
222+
clusterScopeParams.IBMPowerVSCluster.Name = "ClusterName"
223+
networkName := fmt.Sprintf("DHCPSERVER%s_Private", clusterScopeParams.IBMPowerVSCluster.Name)
224+
225+
network := &models.NetworkReference{NetworkID: ptr.To("networkID"), Name: &networkName}
226+
clusterScopeParams.PowerVSClientFactory = func() (powervs.PowerVS, error) {
227+
mockPowerVS.EXPECT().GetNetworkByName(*network.Name).Return(network, nil)
228+
return mockPowerVS, nil
229+
}
230+
231+
clusterScope, _ := NewPowerVSClusterScope(clusterScopeParams)
232+
233+
networkID, err := clusterScope.getNetwork()
234+
g.Expect(err).To(BeNil())
235+
g.Expect(networkID).To(Equal(network.NetworkID))
236+
})
237+
238+
t.Run("When network ID and DHCPServer is empty and GetNetworkByName returns error", func(t *testing.T) {
239+
g := NewWithT(t)
240+
setup(t)
241+
t.Cleanup(teardown)
242+
243+
clusterScopeParams := getPowerVSClusterScopeParams()
244+
clusterScopeParams.IBMPowerVSCluster.Spec.Network = infrav1beta2.IBMPowerVSResourceReference{}
245+
clusterScopeParams.IBMPowerVSCluster.Name = "ClusterName"
246+
networkName := fmt.Sprintf("DHCPSERVER%s_Private", clusterScopeParams.IBMPowerVSCluster.Name)
247+
248+
clusterScopeParams.PowerVSClientFactory = func() (powervs.PowerVS, error) {
249+
mockPowerVS.EXPECT().GetNetworkByName(networkName).Return(nil, fmt.Errorf("GetNetworkByName error"))
250+
return mockPowerVS, nil
251+
}
252+
253+
clusterScope, _ := NewPowerVSClusterScope(clusterScopeParams)
254+
255+
networkID, err := clusterScope.getNetwork()
256+
g.Expect(err).ToNot(BeNil())
257+
g.Expect(networkID).To(BeNil())
258+
})
259+
260+
t.Run("When network ID and DHCPServer is empty and GetNetworkByName returns empty network", func(t *testing.T) {
261+
g := NewWithT(t)
262+
setup(t)
263+
t.Cleanup(teardown)
264+
265+
clusterScopeParams := getPowerVSClusterScopeParams()
266+
clusterScopeParams.IBMPowerVSCluster.Spec.Network = infrav1beta2.IBMPowerVSResourceReference{}
267+
clusterScopeParams.IBMPowerVSCluster.Name = "ClusterName"
268+
networkName := fmt.Sprintf("DHCPSERVER%s_Private", clusterScopeParams.IBMPowerVSCluster.Name)
269+
clusterScopeParams.PowerVSClientFactory = func() (powervs.PowerVS, error) {
270+
mockPowerVS.EXPECT().GetNetworkByName(networkName).Return(nil, nil)
271+
return mockPowerVS, nil
272+
}
273+
274+
clusterScope, _ := NewPowerVSClusterScope(clusterScopeParams)
275+
276+
networkID, err := clusterScope.getNetwork()
277+
g.Expect(err).To(BeNil())
278+
g.Expect(networkID).To(BeNil())
279+
})
280+
}
281+
282+
func TestIsDHCPServerActive(t *testing.T) {
283+
var (
284+
mockPowerVS *mockP.MockPowerVS
285+
mockCtrl *gomock.Controller
286+
)
287+
288+
setup := func(t *testing.T) {
289+
t.Helper()
290+
mockCtrl = gomock.NewController(t)
291+
mockPowerVS = mockP.NewMockPowerVS(mockCtrl)
292+
}
293+
teardown := func() {
294+
mockCtrl.Finish()
295+
}
296+
297+
t.Run("When DHCPID is empty", func(t *testing.T) {
298+
g := NewWithT(t)
299+
setup(t)
300+
t.Cleanup(teardown)
301+
302+
clusterScopeParams := getPowerVSClusterScopeParams()
303+
clusterScopeParams.IBMPowerVSCluster.Spec.DHCPServer.ID = ptr.To("")
304+
clusterScope, _ := NewPowerVSClusterScope(clusterScopeParams)
305+
306+
isActive, err := clusterScope.isDHCPServerActive()
307+
g.Expect(err).To(Equal(fmt.Errorf("DHCP ID is empty")))
308+
g.Expect(isActive).To(BeFalse())
309+
})
310+
t.Run("When GetDHCPServer returns error", func(t *testing.T) {
311+
g := NewWithT(t)
312+
setup(t)
313+
t.Cleanup(teardown)
314+
315+
clusterScopeParams := getPowerVSClusterScopeParams()
316+
clusterScopeParams.PowerVSClientFactory = func() (powervs.PowerVS, error) {
317+
dhcpServer := &models.DHCPServerDetail{ID: ptr.To("dhcpID"), Status: ptr.To(string(infrav1beta2.DHCPServerStateError))}
318+
mockPowerVS.EXPECT().GetDHCPServer(gomock.Any()).Return(dhcpServer, nil)
319+
return mockPowerVS, nil
320+
}
321+
clusterScope, _ := NewPowerVSClusterScope(clusterScopeParams)
322+
323+
isActive, err := clusterScope.isDHCPServerActive()
324+
g.Expect(err).ToNot(BeNil())
325+
g.Expect(isActive).To(BeFalse())
326+
})
327+
}
328+
329+
func TestCheckDHCPServerStatus(t *testing.T) {
330+
testCases := []struct {
331+
name string
332+
dhcpServer models.DHCPServerDetail
333+
expectedStatus bool
334+
}{
335+
{
336+
name: "test DHCP server state build",
337+
dhcpServer: models.DHCPServerDetail{ID: ptr.To("dhcpIDBuild"), Status: ptr.To(string(infrav1beta2.DHCPServerStateBuild))},
338+
expectedStatus: true,
339+
},
340+
{
341+
name: "test DHCP server state active",
342+
dhcpServer: models.DHCPServerDetail{ID: ptr.To("dhcpIDActive"), Status: ptr.To(string(infrav1beta2.DHCPServerStateActive))},
343+
expectedStatus: false,
344+
},
345+
{
346+
name: "test DHCP server state error",
347+
dhcpServer: models.DHCPServerDetail{ID: ptr.To("dhcpIDError"), Status: ptr.To(string(infrav1beta2.DHCPServerStateError))},
348+
expectedStatus: false,
349+
},
350+
{
351+
name: "test DHCP server state invalid value",
352+
dhcpServer: models.DHCPServerDetail{ID: ptr.To("dhcpIDError"), Status: ptr.To("InvalidState")},
353+
expectedStatus: false,
354+
},
355+
}
356+
for _, tc := range testCases {
357+
g := NewWithT(t)
358+
clusterScope := PowerVSClusterScope{}
359+
t.Run(tc.name, func(_ *testing.T) {
360+
status, _ := clusterScope.checkDHCPServerStatus(tc.dhcpServer)
361+
g.Expect(status).To(Equal(tc.expectedStatus))
362+
})
363+
}
364+
365+
}
366+
367+
func TestCreateDHCPServer(t *testing.T) {
368+
var (
369+
mockPowerVS *mockP.MockPowerVS
370+
mockCtrl *gomock.Controller
371+
)
372+
373+
setup := func(t *testing.T) {
374+
t.Helper()
375+
mockCtrl = gomock.NewController(t)
376+
mockPowerVS = mockP.NewMockPowerVS(mockCtrl)
377+
}
378+
teardown := func() {
379+
mockCtrl.Finish()
380+
}
381+
t.Run("When dhcpServerDetails is empty", func(t *testing.T) {
382+
g := NewWithT(t)
383+
setup(t)
384+
t.Cleanup(teardown)
385+
386+
dhcpNetwork := &models.DHCPServerNetwork{ID: ptr.To("dhcpNetworkID")}
387+
dhcpServer := &models.DHCPServer{ID: ptr.To("dhcpID"), Network: dhcpNetwork}
388+
clusterScopeParams := getPowerVSClusterScopeParams()
389+
clusterScopeParams.IBMPowerVSCluster.Spec.DHCPServer = nil
390+
clusterScopeParams.IBMPowerVSCluster.Name = "clusterName"
391+
clusterScopeParams.PowerVSClientFactory = func() (powervs.PowerVS, error) {
392+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(dhcpServer, nil)
393+
return mockPowerVS, nil
394+
}
395+
clusterScope, _ := NewPowerVSClusterScope(clusterScopeParams)
396+
dhcpID, err := clusterScope.createDHCPServer()
397+
g.Expect(dhcpID).To(Equal(dhcpServer.ID))
398+
g.Expect(err).To(BeNil())
399+
g.Expect(clusterScope.IBMPowerVSCluster.Status.Network.ID).To(Equal(dhcpNetwork.ID))
400+
})
401+
402+
t.Run("When dhcpServerDetails are all set properly", func(t *testing.T) {
403+
g := NewWithT(t)
404+
setup(t)
405+
t.Cleanup(teardown)
406+
407+
//dhcpNetwork := &models.DHCPServerNetwork{ID: ptr.To("dhcpNetworkID")}
408+
dhcpServer := &models.DHCPServer{ID: ptr.To("dhcpID")}
409+
clusterScopeParams := getPowerVSClusterScopeParams()
410+
clusterScopeParams.IBMPowerVSCluster.Spec.DHCPServer.DNSServer = ptr.To("DNSServer")
411+
clusterScopeParams.IBMPowerVSCluster.Spec.DHCPServer.Cidr = ptr.To("10.10.1.10/24")
412+
clusterScopeParams.IBMPowerVSCluster.Spec.DHCPServer.Snat = ptr.To(true)
413+
clusterScopeParams.IBMPowerVSCluster.Name = "clusterName"
414+
clusterScopeParams.PowerVSClientFactory = func() (powervs.PowerVS, error) {
415+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(dhcpServer, nil)
416+
return mockPowerVS, nil
417+
}
418+
clusterScope, _ := NewPowerVSClusterScope(clusterScopeParams)
419+
dhcpID, err := clusterScope.createDHCPServer()
420+
g.Expect(dhcpID).To(BeNil())
421+
g.Expect(err).ToNot(BeNil())
422+
})
423+
424+
t.Run("When dhcpServerDetails are all set properly", func(t *testing.T) {
425+
g := NewWithT(t)
426+
setup(t)
427+
t.Cleanup(teardown)
428+
429+
clusterScopeParams := getPowerVSClusterScopeParams()
430+
clusterScopeParams.IBMPowerVSCluster.Name = "clusterName"
431+
clusterScopeParams.PowerVSClientFactory = func() (powervs.PowerVS, error) {
432+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(nil, nil)
433+
return mockPowerVS, nil
434+
}
435+
clusterScope, _ := NewPowerVSClusterScope(clusterScopeParams)
436+
dhcpID, err := clusterScope.createDHCPServer()
437+
g.Expect(dhcpID).To(BeNil())
438+
g.Expect(err).ToNot(BeNil())
439+
})
440+
}
161441
func TestReconcileNetwork(t *testing.T) {
162442
var (
163443
mockPowerVS *mockP.MockPowerVS
@@ -243,40 +523,16 @@ func TestReconcileNetwork(t *testing.T) {
243523
g.Expect(err).To(BeNil())
244524
g.Expect(requeue).To(BeFalse())
245525
})
246-
t.Run("When DHCPID is empty and GetNetworkByName returns empty network", func(t *testing.T) {
526+
t.Run("When DHCPID is empty and checkNetwork returns empty network ID", func(t *testing.T) {
247527
g := NewWithT(t)
248528
setup(t)
249529
t.Cleanup(teardown)
250530

251-
network := &models.NetworkReference{}
531+
network := &models.Network{}
252532
dhcpNetwork := &models.DHCPServerNetwork{ID: ptr.To("dhcpNetworkID")}
253533
dhcpServer := &models.DHCPServer{ID: ptr.To("dhcpID"), Network: dhcpNetwork}
254534
clusterScopeParams := getPowerVSClusterScopeParams()
255535
clusterScopeParams.PowerVSClientFactory = func() (powervs.PowerVS, error) {
256-
mockPowerVS.EXPECT().GetNetworkByName(gomock.Any()).Return(network, nil)
257-
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(dhcpServer, nil)
258-
return mockPowerVS, nil
259-
}
260-
clusterScopeParams.IBMPowerVSCluster.Spec.DHCPServer.ID = nil
261-
clusterScope, _ := NewPowerVSClusterScope(clusterScopeParams)
262-
263-
requeue, err := clusterScope.ReconcileNetwork()
264-
g.Expect(clusterScope.IBMPowerVSCluster.Status.DHCPServer.ID).To(Equal(dhcpServer.ID))
265-
g.Expect(clusterScope.IBMPowerVSCluster.Status.Network.ID).To(Equal(dhcpNetwork.ID))
266-
g.Expect(err).To(BeNil())
267-
g.Expect(requeue).To(BeTrue())
268-
269-
})
270-
t.Run("When DHCPID is empty and checkNetwork returns empty network ID", func(t *testing.T) {
271-
g := NewWithT(t)
272-
setup(t)
273-
t.Cleanup(teardown)
274-
275-
clusterScopeParams := getPowerVSClusterScopeParams()
276-
clusterScopeParams.PowerVSClientFactory = func() (powervs.PowerVS, error) {
277-
network := &models.Network{}
278-
dhcpNetwork := &models.DHCPServerNetwork{ID: ptr.To("dhcpNetworkID")}
279-
dhcpServer := &models.DHCPServer{ID: ptr.To("dhcpID"), Network: dhcpNetwork}
280536
mockPowerVS.EXPECT().GetNetworkByID(gomock.Any()).Return(network, nil)
281537
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(dhcpServer, nil)
282538
return mockPowerVS, nil
@@ -286,6 +542,8 @@ func TestReconcileNetwork(t *testing.T) {
286542
clusterScope, _ := NewPowerVSClusterScope(clusterScopeParams)
287543

288544
requeue, err := clusterScope.ReconcileNetwork()
545+
g.Expect(clusterScope.IBMPowerVSCluster.Status.DHCPServer.ID).To(Equal(dhcpServer.ID))
546+
g.Expect(clusterScope.IBMPowerVSCluster.Status.Network.ID).To(Equal(dhcpNetwork.ID))
289547
g.Expect(err).To(BeNil())
290548
g.Expect(requeue).To(BeTrue())
291549

0 commit comments

Comments
 (0)