Skip to content

Commit 5e547ec

Browse files
Shilpa-GokulShilpa-Gokul
authored
Add UT for ReconcileNetwork function (#1928)
1 parent 3a84167 commit 5e547ec

File tree

1 file changed

+325
-0
lines changed

1 file changed

+325
-0
lines changed

‎cloud/scope/powervs_cluster_test.go

Lines changed: 325 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,7 @@ import (
2121
"fmt"
2222
"testing"
2323

24+
"github.com/IBM-Cloud/power-go-client/power/models"
2425
"github.com/IBM/go-sdk-core/v5/core"
2526
"github.com/IBM/platform-services-go-sdk/resourcecontrollerv2"
2627
"github.com/IBM/vpc-go-sdk/vpcv1"
@@ -30,6 +31,7 @@ import (
3031
"k8s.io/utils/ptr"
3132

3233
infrav1beta2 "sigs.k8s.io/cluster-api-provider-ibmcloud/api/v1beta2"
34+
mockP "sigs.k8s.io/cluster-api-provider-ibmcloud/pkg/cloud/services/powervs/mock"
3335
capiv1beta1 "sigs.k8s.io/cluster-api/api/v1beta1"
3436

3537
"sigs.k8s.io/cluster-api-provider-ibmcloud/cmd/capibmadm/utils"
@@ -2222,3 +2224,326 @@ func TestCheckVPC(t *testing.T) {
22222224
g.Expect(vpcID).To(Equal(""))
22232225
})
22242226
}
2227+
2228+
func TestIsDHCPServerActive(t *testing.T) {
2229+
var (
2230+
mockPowerVS *mockP.MockPowerVS
2231+
mockCtrl *gomock.Controller
2232+
)
2233+
2234+
setup := func(t *testing.T) {
2235+
t.Helper()
2236+
mockCtrl = gomock.NewController(t)
2237+
mockPowerVS = mockP.NewMockPowerVS(mockCtrl)
2238+
}
2239+
teardown := func() {
2240+
mockCtrl.Finish()
2241+
}
2242+
2243+
t.Run("When GetDHCPServer returns error", func(t *testing.T) {
2244+
g := NewWithT(t)
2245+
setup(t)
2246+
t.Cleanup(teardown)
2247+
clusterScope := PowerVSClusterScope{
2248+
IBMPowerVSClient: mockPowerVS,
2249+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Status: infrav1beta2.IBMPowerVSClusterStatus{DHCPServer: &infrav1beta2.ResourceReference{ID: ptr.To("dhcpID")}}},
2250+
}
2251+
mockPowerVS.EXPECT().GetDHCPServer(gomock.Any()).Return(nil, fmt.Errorf("GetDHCPServer returns error"))
2252+
isActive, err := clusterScope.isDHCPServerActive()
2253+
g.Expect(err).ToNot(BeNil())
2254+
g.Expect(isActive).To(BeFalse())
2255+
})
2256+
t.Run("When checkDHCPServerStatus returns error state", func(t *testing.T) {
2257+
g := NewWithT(t)
2258+
setup(t)
2259+
t.Cleanup(teardown)
2260+
2261+
dhcpServer := &models.DHCPServerDetail{ID: ptr.To("dhcpID"), Status: ptr.To(string(infrav1beta2.DHCPServerStateError))}
2262+
clusterScope := PowerVSClusterScope{
2263+
IBMPowerVSClient: mockPowerVS,
2264+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Status: infrav1beta2.IBMPowerVSClusterStatus{DHCPServer: &infrav1beta2.ResourceReference{ID: ptr.To("dhcpID")}}},
2265+
}
2266+
mockPowerVS.EXPECT().GetDHCPServer(gomock.Any()).Return(dhcpServer, nil)
2267+
2268+
isActive, err := clusterScope.isDHCPServerActive()
2269+
g.Expect(err).ToNot(BeNil())
2270+
g.Expect(isActive).To(BeFalse())
2271+
})
2272+
t.Run("When checkDHCPServerStatus returns active state", func(t *testing.T) {
2273+
g := NewWithT(t)
2274+
setup(t)
2275+
t.Cleanup(teardown)
2276+
2277+
dhcpServer := &models.DHCPServerDetail{ID: ptr.To("dhcpID"), Status: ptr.To(string(infrav1beta2.DHCPServerStateActive))}
2278+
clusterScope := PowerVSClusterScope{
2279+
IBMPowerVSClient: mockPowerVS,
2280+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Status: infrav1beta2.IBMPowerVSClusterStatus{DHCPServer: &infrav1beta2.ResourceReference{ID: ptr.To("dhcpID")}}},
2281+
}
2282+
mockPowerVS.EXPECT().GetDHCPServer(gomock.Any()).Return(dhcpServer, nil)
2283+
2284+
isActive, err := clusterScope.isDHCPServerActive()
2285+
g.Expect(err).To(BeNil())
2286+
g.Expect(isActive).To(BeTrue())
2287+
})
2288+
}
2289+
2290+
func TestCheckDHCPServerStatus(t *testing.T) {
2291+
testCases := []struct {
2292+
name string
2293+
dhcpServer models.DHCPServerDetail
2294+
expectedStatus bool
2295+
}{
2296+
{
2297+
name: "DHCP server is in build state",
2298+
dhcpServer: models.DHCPServerDetail{ID: ptr.To("dhcpIDBuild"), Status: ptr.To(string(infrav1beta2.DHCPServerStateBuild))},
2299+
expectedStatus: false,
2300+
},
2301+
{
2302+
name: "DHCP server is in active state",
2303+
dhcpServer: models.DHCPServerDetail{ID: ptr.To("dhcpIDActive"), Status: ptr.To(string(infrav1beta2.DHCPServerStateActive))},
2304+
expectedStatus: true,
2305+
},
2306+
{
2307+
name: "DHCP server is in error state",
2308+
dhcpServer: models.DHCPServerDetail{ID: ptr.To("dhcpIDError"), Status: ptr.To(string(infrav1beta2.DHCPServerStateError))},
2309+
expectedStatus: false,
2310+
},
2311+
{
2312+
name: "DHCP server is in invalid state",
2313+
dhcpServer: models.DHCPServerDetail{ID: ptr.To("dhcpIDError"), Status: ptr.To("InvalidState")},
2314+
expectedStatus: false,
2315+
},
2316+
}
2317+
for _, tc := range testCases {
2318+
g := NewWithT(t)
2319+
clusterScope := PowerVSClusterScope{}
2320+
t.Run(tc.name, func(_ *testing.T) {
2321+
status, _ := clusterScope.checkDHCPServerStatus(tc.dhcpServer)
2322+
g.Expect(status).To(Equal(tc.expectedStatus))
2323+
})
2324+
}
2325+
}
2326+
2327+
func TestCreateDHCPServer(t *testing.T) {
2328+
var (
2329+
mockPowerVS *mockP.MockPowerVS
2330+
mockCtrl *gomock.Controller
2331+
clusterName = "clusterName"
2332+
)
2333+
2334+
setup := func(t *testing.T) {
2335+
t.Helper()
2336+
mockCtrl = gomock.NewController(t)
2337+
mockPowerVS = mockP.NewMockPowerVS(mockCtrl)
2338+
}
2339+
teardown := func() {
2340+
mockCtrl.Finish()
2341+
}
2342+
2343+
t.Run("When dhcpServerDetails is empty", func(t *testing.T) {
2344+
g := NewWithT(t)
2345+
setup(t)
2346+
t.Cleanup(teardown)
2347+
2348+
dhcpNetwork := &models.DHCPServerNetwork{ID: ptr.To("dhcpNetworkID")}
2349+
dhcpServer := &models.DHCPServer{ID: ptr.To("dhcpID"), Network: dhcpNetwork}
2350+
clusterScope := PowerVSClusterScope{
2351+
IBMPowerVSClient: mockPowerVS,
2352+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{ObjectMeta: metav1.ObjectMeta{Name: clusterName}},
2353+
}
2354+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(dhcpServer, nil)
2355+
dhcpID, err := clusterScope.createDHCPServer()
2356+
g.Expect(dhcpID).To(Equal(dhcpServer.ID))
2357+
g.Expect(err).To(BeNil())
2358+
g.Expect(clusterScope.IBMPowerVSCluster.Status.Network.ID).To(Equal(dhcpNetwork.ID))
2359+
})
2360+
2361+
t.Run("When dhcpServerDetails are all set but createDHCPServer returns server with no network", func(t *testing.T) {
2362+
g := NewWithT(t)
2363+
setup(t)
2364+
t.Cleanup(teardown)
2365+
2366+
dhcpServer := &models.DHCPServer{ID: ptr.To("dhcpID")}
2367+
clusterScope := PowerVSClusterScope{
2368+
IBMPowerVSClient: mockPowerVS,
2369+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{
2370+
ObjectMeta: metav1.ObjectMeta{Name: clusterName},
2371+
Spec: infrav1beta2.IBMPowerVSClusterSpec{DHCPServer: &infrav1beta2.DHCPServer{
2372+
ID: ptr.To("dhcpID"),
2373+
DNSServer: ptr.To("DNSServer"),
2374+
Cidr: ptr.To("10.10.1.10/24"),
2375+
Snat: ptr.To(true),
2376+
}},
2377+
},
2378+
}
2379+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(dhcpServer, nil)
2380+
dhcpID, err := clusterScope.createDHCPServer()
2381+
g.Expect(dhcpID).To(BeNil())
2382+
g.Expect(err).ToNot(BeNil())
2383+
})
2384+
2385+
t.Run("When dhcpServerDetails has no dnsserver,cidr or snat set", func(t *testing.T) {
2386+
g := NewWithT(t)
2387+
setup(t)
2388+
t.Cleanup(teardown)
2389+
2390+
dhcpNetwork := &models.DHCPServerNetwork{ID: ptr.To("dhcpNetworkID")}
2391+
dhcpServer := &models.DHCPServer{ID: ptr.To("dhcpID"), Network: dhcpNetwork}
2392+
clusterScope := PowerVSClusterScope{
2393+
IBMPowerVSClient: mockPowerVS,
2394+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{ObjectMeta: metav1.ObjectMeta{Name: clusterName}},
2395+
}
2396+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(dhcpServer, nil)
2397+
dhcpID, err := clusterScope.createDHCPServer()
2398+
g.Expect(dhcpID).To(Equal(dhcpServer.ID))
2399+
g.Expect(err).To(BeNil())
2400+
g.Expect(clusterScope.IBMPowerVSCluster.Status.Network.ID).To(Equal(dhcpNetwork.ID))
2401+
})
2402+
2403+
t.Run("When CreateDHCPServer returns empty dhcp server", func(t *testing.T) {
2404+
g := NewWithT(t)
2405+
setup(t)
2406+
t.Cleanup(teardown)
2407+
2408+
clusterScope := PowerVSClusterScope{
2409+
IBMPowerVSClient: mockPowerVS,
2410+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{ObjectMeta: metav1.ObjectMeta{Name: clusterName}},
2411+
}
2412+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(nil, nil)
2413+
dhcpID, err := clusterScope.createDHCPServer()
2414+
g.Expect(dhcpID).To(BeNil())
2415+
g.Expect(err).ToNot(BeNil())
2416+
})
2417+
2418+
t.Run("When CreateDHCPServer returns error", func(t *testing.T) {
2419+
g := NewWithT(t)
2420+
setup(t)
2421+
t.Cleanup(teardown)
2422+
2423+
clusterScope := PowerVSClusterScope{
2424+
IBMPowerVSClient: mockPowerVS,
2425+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{ObjectMeta: metav1.ObjectMeta{Name: clusterName}},
2426+
}
2427+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(nil, fmt.Errorf("CreateDHCPServer returns error"))
2428+
dhcpID, err := clusterScope.createDHCPServer()
2429+
g.Expect(dhcpID).To(BeNil())
2430+
g.Expect(err).ToNot(BeNil())
2431+
})
2432+
}
2433+
2434+
func TestReconcileNetwork(t *testing.T) {
2435+
var (
2436+
mockPowerVS *mockP.MockPowerVS
2437+
mockCtrl *gomock.Controller
2438+
)
2439+
2440+
setup := func(t *testing.T) {
2441+
t.Helper()
2442+
mockCtrl = gomock.NewController(t)
2443+
mockPowerVS = mockP.NewMockPowerVS(mockCtrl)
2444+
}
2445+
teardown := func() {
2446+
mockCtrl.Finish()
2447+
}
2448+
t.Run("When GetDHCPServer returns error", func(t *testing.T) {
2449+
g := NewWithT(t)
2450+
setup(t)
2451+
t.Cleanup(teardown)
2452+
2453+
clusterScope := PowerVSClusterScope{
2454+
IBMPowerVSClient: mockPowerVS,
2455+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Status: infrav1beta2.IBMPowerVSClusterStatus{DHCPServer: &infrav1beta2.ResourceReference{ID: ptr.To("dhcpID")}}},
2456+
}
2457+
mockPowerVS.EXPECT().GetDHCPServer(gomock.Any()).Return(nil, fmt.Errorf("GetDHCPServer error"))
2458+
2459+
requeue, err := clusterScope.ReconcileNetwork()
2460+
g.Expect(err).ToNot(BeNil())
2461+
g.Expect(requeue).To(BeFalse())
2462+
})
2463+
t.Run("When DHCPServer exists and is active", func(t *testing.T) {
2464+
g := NewWithT(t)
2465+
setup(t)
2466+
t.Cleanup(teardown)
2467+
2468+
clusterScope := PowerVSClusterScope{
2469+
IBMPowerVSClient: mockPowerVS,
2470+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Status: infrav1beta2.IBMPowerVSClusterStatus{DHCPServer: &infrav1beta2.ResourceReference{ID: ptr.To("dhcpID")}}},
2471+
}
2472+
2473+
dhcpServer := &models.DHCPServerDetail{ID: ptr.To("dhcpID"), Status: ptr.To(string(infrav1beta2.DHCPServerStateActive))}
2474+
mockPowerVS.EXPECT().GetDHCPServer(gomock.Any()).Return(dhcpServer, nil)
2475+
2476+
requeue, err := clusterScope.ReconcileNetwork()
2477+
g.Expect(err).To(BeNil())
2478+
g.Expect(requeue).To(BeTrue())
2479+
})
2480+
t.Run("When DHCPID is empty and GetNetworkByID returns error ", func(t *testing.T) {
2481+
g := NewWithT(t)
2482+
setup(t)
2483+
t.Cleanup(teardown)
2484+
2485+
clusterScope := PowerVSClusterScope{
2486+
IBMPowerVSClient: mockPowerVS,
2487+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Spec: infrav1beta2.IBMPowerVSClusterSpec{
2488+
Network: infrav1beta2.IBMPowerVSResourceReference{ID: ptr.To("networkID")}}},
2489+
}
2490+
network := &models.Network{}
2491+
mockPowerVS.EXPECT().GetNetworkByID(gomock.Any()).Return(network, fmt.Errorf("GetNetworkByID error"))
2492+
2493+
requeue, err := clusterScope.ReconcileNetwork()
2494+
g.Expect(err).ToNot(BeNil())
2495+
g.Expect(requeue).To(BeFalse())
2496+
})
2497+
t.Run("When DHCPID is empty and networkID is not empty", func(t *testing.T) {
2498+
g := NewWithT(t)
2499+
setup(t)
2500+
t.Cleanup(teardown)
2501+
network := &models.Network{NetworkID: ptr.To("networkID")}
2502+
clusterScope := PowerVSClusterScope{
2503+
IBMPowerVSClient: mockPowerVS,
2504+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Spec: infrav1beta2.IBMPowerVSClusterSpec{
2505+
Network: infrav1beta2.IBMPowerVSResourceReference{ID: ptr.To("networkID")}}},
2506+
}
2507+
mockPowerVS.EXPECT().GetNetworkByID(gomock.Any()).Return(network, nil)
2508+
requeue, err := clusterScope.ReconcileNetwork()
2509+
g.Expect(clusterScope.IBMPowerVSCluster.Status.Network.ID).To(Equal(network.NetworkID))
2510+
g.Expect(err).To(BeNil())
2511+
g.Expect(requeue).To(BeTrue())
2512+
})
2513+
t.Run("When network name is set in spec and DHCP server is created successfully", func(t *testing.T) {
2514+
g := NewWithT(t)
2515+
setup(t)
2516+
t.Cleanup(teardown)
2517+
2518+
dhcpNetwork := &models.DHCPServerNetwork{ID: ptr.To("dhcpNetworkID")}
2519+
dhcpServer := &models.DHCPServer{ID: ptr.To("dhcpID"), Network: dhcpNetwork}
2520+
clusterScope := PowerVSClusterScope{
2521+
IBMPowerVSClient: mockPowerVS,
2522+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Spec: infrav1beta2.IBMPowerVSClusterSpec{
2523+
Network: infrav1beta2.IBMPowerVSResourceReference{Name: ptr.To("networkName")}}},
2524+
}
2525+
mockPowerVS.EXPECT().GetNetworkByName(gomock.Any()).Return(nil, nil)
2526+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(dhcpServer, nil)
2527+
requeue, err := clusterScope.ReconcileNetwork()
2528+
g.Expect(clusterScope.IBMPowerVSCluster.Status.DHCPServer.ID).To(Equal(dhcpServer.ID))
2529+
g.Expect(clusterScope.IBMPowerVSCluster.Status.Network.ID).To(Equal(dhcpNetwork.ID))
2530+
g.Expect(err).To(BeNil())
2531+
g.Expect(requeue).To(BeFalse())
2532+
})
2533+
t.Run("When network name is set in spec and createDHCPServer returns error", func(t *testing.T) {
2534+
g := NewWithT(t)
2535+
setup(t)
2536+
t.Cleanup(teardown)
2537+
2538+
clusterScope := PowerVSClusterScope{
2539+
IBMPowerVSClient: mockPowerVS,
2540+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Spec: infrav1beta2.IBMPowerVSClusterSpec{
2541+
Network: infrav1beta2.IBMPowerVSResourceReference{Name: ptr.To("networkName")}}},
2542+
}
2543+
mockPowerVS.EXPECT().GetNetworkByName(gomock.Any()).Return(nil, nil)
2544+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(nil, fmt.Errorf("CreateDHCPServer error"))
2545+
requeue, err := clusterScope.ReconcileNetwork()
2546+
g.Expect(err).ToNot(BeNil())
2547+
g.Expect(requeue).To(BeFalse())
2548+
})
2549+
}

0 commit comments

Comments
 (0)