Skip to content

Commit f956588

Browse files
Shilpa-GokulShilpa-Gokul
committed
Cover UT for getNetwork and isDHCPServerActive functions
1 parent b23d800 commit f956588

File tree

1 file changed

+194
-24
lines changed

1 file changed

+194
-24
lines changed

‎cloud/scope/powervs_cluster_test.go

Lines changed: 194 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -158,6 +158,174 @@ 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+
161329
func TestReconcileNetwork(t *testing.T) {
162330
var (
163331
mockPowerVS *mockP.MockPowerVS
@@ -243,40 +411,40 @@ func TestReconcileNetwork(t *testing.T) {
243411
g.Expect(err).To(BeNil())
244412
g.Expect(requeue).To(BeFalse())
245413
})
246-
t.Run("When DHCPID is empty and GetNetworkByName returns empty network", func(t *testing.T) {
247-
g := NewWithT(t)
248-
setup(t)
249-
t.Cleanup(teardown)
414+
// t.Run("When DHCPID is empty and GetNetworkByName returns empty network", func(t *testing.T) {
415+
// g := NewWithT(t)
416+
// setup(t)
417+
// t.Cleanup(teardown)
250418

251-
network := &models.NetworkReference{}
252-
dhcpNetwork := &models.DHCPServerNetwork{ID: ptr.To("dhcpNetworkID")}
253-
dhcpServer := &models.DHCPServer{ID: ptr.To("dhcpID"), Network: dhcpNetwork}
254-
clusterScopeParams := getPowerVSClusterScopeParams()
255-
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)
419+
// network := &models.NetworkReference{}
420+
// dhcpNetwork := &models.DHCPServerNetwork{ID: ptr.To("dhcpNetworkID")}
421+
// dhcpServer := &models.DHCPServer{ID: ptr.To("dhcpID"), Network: dhcpNetwork}
422+
// clusterScopeParams := getPowerVSClusterScopeParams()
423+
// clusterScopeParams.PowerVSClientFactory = func() (powervs.PowerVS, error) {
424+
// mockPowerVS.EXPECT().GetNetworkByName(gomock.Any()).Return(network, nil)
425+
// mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(dhcpServer, nil)
426+
// return mockPowerVS, nil
427+
// }
428+
// clusterScopeParams.IBMPowerVSCluster.Spec.DHCPServer.ID = nil
429+
// clusterScope, _ := NewPowerVSClusterScope(clusterScopeParams)
262430

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())
431+
// requeue, err := clusterScope.ReconcileNetwork()
432+
// g.Expect(clusterScope.IBMPowerVSCluster.Status.DHCPServer.ID).To(Equal(dhcpServer.ID))
433+
// g.Expect(clusterScope.IBMPowerVSCluster.Status.Network.ID).To(Equal(dhcpNetwork.ID))
434+
// g.Expect(err).To(BeNil())
435+
// g.Expect(requeue).To(BeTrue())
268436

269-
})
437+
// })
270438
t.Run("When DHCPID is empty and checkNetwork returns empty network ID", func(t *testing.T) {
271439
g := NewWithT(t)
272440
setup(t)
273441
t.Cleanup(teardown)
274442

443+
network := &models.Network{}
444+
dhcpNetwork := &models.DHCPServerNetwork{ID: ptr.To("dhcpNetworkID")}
445+
dhcpServer := &models.DHCPServer{ID: ptr.To("dhcpID"), Network: dhcpNetwork}
275446
clusterScopeParams := getPowerVSClusterScopeParams()
276447
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}
280448
mockPowerVS.EXPECT().GetNetworkByID(gomock.Any()).Return(network, nil)
281449
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(dhcpServer, nil)
282450
return mockPowerVS, nil
@@ -286,6 +454,8 @@ func TestReconcileNetwork(t *testing.T) {
286454
clusterScope, _ := NewPowerVSClusterScope(clusterScopeParams)
287455

288456
requeue, err := clusterScope.ReconcileNetwork()
457+
g.Expect(clusterScope.IBMPowerVSCluster.Status.DHCPServer.ID).To(Equal(dhcpServer.ID))
458+
g.Expect(clusterScope.IBMPowerVSCluster.Status.Network.ID).To(Equal(dhcpNetwork.ID))
289459
g.Expect(err).To(BeNil())
290460
g.Expect(requeue).To(BeTrue())
291461

0 commit comments

Comments
 (0)