Skip to content

Commit 4446e21

Browse files
carmal891carmal891
committed
Refactored ReconcileLB UT
1 parent e381df3 commit 4446e21

File tree

1 file changed

+45
-103
lines changed

1 file changed

+45
-103
lines changed

‎cloud/scope/powervs_cluster_test.go

Lines changed: 45 additions & 103 deletions
Original file line numberDiff line numberDiff line change
@@ -1172,7 +1172,7 @@ func TestReconcileLoadBalancers(t *testing.T) {
11721172
mockCtrl.Finish()
11731173
}
11741174

1175-
t.Run("When LoadBalancer ID is set and GetLoadbalancer returns error", func(t *testing.T) {
1175+
t.Run("When LoadBalancer ID is set and GetLoadbalancer fails to fetch loadbalancer details", func(t *testing.T) {
11761176
g := NewWithT(t)
11771177
setup(t)
11781178
t.Cleanup(teardown)
@@ -1192,9 +1192,9 @@ func TestReconcileLoadBalancers(t *testing.T) {
11921192

11931193
mockVpc.EXPECT().GetLoadBalancer(gomock.Any()).Return(nil, nil, errors.New("failed to fetch VPC load balancer details"))
11941194

1195-
requeue, err := clusterScope.ReconcileLoadBalancers()
1195+
loadBalancerReady, err := clusterScope.ReconcileLoadBalancers()
11961196
g.Expect(err).ToNot(BeNil())
1197-
g.Expect(requeue).To(BeFalse())
1197+
g.Expect(loadBalancerReady).To(BeFalse())
11981198
})
11991199

12001200
t.Run("When LoadBalancer ID is set and the checkLoadBalancerStatus returns status is not active, indicating that load balancer is still not ready", func(t *testing.T) {
@@ -1221,9 +1221,9 @@ func TestReconcileLoadBalancers(t *testing.T) {
12211221
Name: ptr.To("test-lb"),
12221222
}, nil, nil)
12231223

1224-
requeue, err := clusterScope.ReconcileLoadBalancers()
1224+
loadBalancerReady, err := clusterScope.ReconcileLoadBalancers()
12251225
g.Expect(err).To(BeNil())
1226-
g.Expect(requeue).To(BeFalse())
1226+
g.Expect(loadBalancerReady).To(BeFalse())
12271227
})
12281228

12291229
t.Run("Reconcile should not requeue when one load balancer is ready but another is still initializing or inactive", func(t *testing.T) {
@@ -1259,9 +1259,9 @@ func TestReconcileLoadBalancers(t *testing.T) {
12591259
Name: ptr.To("test-inactive-lb"),
12601260
}, nil, nil)
12611261

1262-
requeue, err := clusterScope.ReconcileLoadBalancers()
1262+
loadBalancerReady, err := clusterScope.ReconcileLoadBalancers()
12631263
g.Expect(err).To(BeNil())
1264-
g.Expect(requeue).To(BeFalse())
1264+
g.Expect(loadBalancerReady).To(BeFalse())
12651265
})
12661266

12671267
t.Run("When LoadBalancer ID is set, checkLoadBalancerStatus returns status active", func(t *testing.T) {
@@ -1289,8 +1289,8 @@ func TestReconcileLoadBalancers(t *testing.T) {
12891289
Name: ptr.To("test-lb"),
12901290
}, nil, nil)
12911291

1292-
requeue, err := clusterScope.ReconcileLoadBalancers()
1293-
g.Expect(requeue).To(BeTrue())
1292+
loadBalancerReady, err := clusterScope.ReconcileLoadBalancers()
1293+
g.Expect(loadBalancerReady).To(BeTrue())
12941294
g.Expect(err).To(BeNil())
12951295

12961296
loadBalancerStatus, ok := clusterScope.IBMPowerVSCluster.Status.LoadBalancers["test-lb"]
@@ -1300,7 +1300,7 @@ func TestReconcileLoadBalancers(t *testing.T) {
13001300
g.Expect(loadBalancerStatus.Hostname).To(Equal(ptr.To("test-lb-hostname")))
13011301
})
13021302

1303-
t.Run("When LoadBalancer ID is not set and checkLoadBalancer returns an error", func(t *testing.T) {
1303+
t.Run("When LoadBalancer ID is not set and checkLoadBalancer fails to fetch load balancer", func(t *testing.T) {
13041304
g := NewWithT(t)
13051305
setup(t)
13061306
t.Cleanup(teardown)
@@ -1320,8 +1320,8 @@ func TestReconcileLoadBalancers(t *testing.T) {
13201320

13211321
mockVpc.EXPECT().GetLoadBalancerByName(gomock.Any()).Return(nil, errors.New("failed to get load balancer by name"))
13221322

1323-
requeue, err := clusterScope.ReconcileLoadBalancers()
1324-
g.Expect(requeue).To(BeFalse())
1323+
loadBalancerReady, err := clusterScope.ReconcileLoadBalancers()
1324+
g.Expect(loadBalancerReady).To(BeFalse())
13251325
g.Expect(err).ToNot(BeNil())
13261326
})
13271327

@@ -1345,8 +1345,8 @@ func TestReconcileLoadBalancers(t *testing.T) {
13451345

13461346
mockVpc.EXPECT().GetLoadBalancerByName(gomock.Any()).Return(nil, nil)
13471347

1348-
requeue, err := clusterScope.ReconcileLoadBalancers()
1349-
g.Expect(requeue).To(BeFalse())
1348+
loadBalancerReady, err := clusterScope.ReconcileLoadBalancers()
1349+
g.Expect(loadBalancerReady).To(BeFalse())
13501350
g.Expect(err).ToNot(BeNil())
13511351
})
13521352

@@ -1376,8 +1376,8 @@ func TestReconcileLoadBalancers(t *testing.T) {
13761376
ID: ptr.To("test-lb-instanceid"),
13771377
}, nil)
13781378

1379-
requeue, err := clusterScope.ReconcileLoadBalancers()
1380-
g.Expect(requeue).To(BeTrue())
1379+
loadBalancerReady, err := clusterScope.ReconcileLoadBalancers()
1380+
g.Expect(loadBalancerReady).To(BeTrue())
13811381
g.Expect(err).To(BeNil())
13821382

13831383
loadBalancerStatus, ok := clusterScope.IBMPowerVSCluster.Status.LoadBalancers["test-lb"]
@@ -1387,7 +1387,7 @@ func TestReconcileLoadBalancers(t *testing.T) {
13871387
g.Expect(loadBalancerStatus.Hostname).To(Equal(ptr.To("test-lb-hostname")))
13881388
})
13891389

1390-
t.Run("checkLoadBalancerPort should return an error when load balancer port matches with API server port", func(t *testing.T) {
1390+
t.Run("when checkLoadBalancerPort returns an error", func(t *testing.T) {
13911391
g := NewWithT(t)
13921392
setup(t)
13931393
t.Cleanup(teardown)
@@ -1421,70 +1421,12 @@ func TestReconcileLoadBalancers(t *testing.T) {
14211421

14221422
mockVpc.EXPECT().GetLoadBalancerByName(gomock.Any()).Return(nil, nil)
14231423

1424-
requeue, err := clusterScope.ReconcileLoadBalancers()
1425-
g.Expect(requeue).To(BeFalse())
1424+
loadBalancerReady, err := clusterScope.ReconcileLoadBalancers()
1425+
g.Expect(loadBalancerReady).To(BeFalse())
14261426
g.Expect(err).ToNot(BeNil())
14271427
})
14281428

1429-
t.Run("When createLoadBalancer returns error as resource group id is empty", func(*testing.T) {
1430-
g := NewWithT(t)
1431-
setup(t)
1432-
t.Cleanup(teardown)
1433-
1434-
clusterScope := PowerVSClusterScope{
1435-
IBMVPCClient: mockVpc,
1436-
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{
1437-
Spec: infrav1beta2.IBMPowerVSClusterSpec{
1438-
ResourceGroup: &infrav1beta2.IBMPowerVSResourceReference{
1439-
ID: ptr.To(""),
1440-
},
1441-
LoadBalancers: []infrav1beta2.VPCLoadBalancerSpec{
1442-
{
1443-
Name: "test-lb",
1444-
ID: nil,
1445-
},
1446-
},
1447-
},
1448-
},
1449-
}
1450-
1451-
mockVpc.EXPECT().GetLoadBalancerByName(gomock.Any()).Return(nil, nil)
1452-
1453-
requeue, err := clusterScope.ReconcileLoadBalancers()
1454-
g.Expect(requeue).To(BeFalse())
1455-
g.Expect(err).ToNot(BeNil())
1456-
})
1457-
1458-
t.Run("When createLoadBalancer returns error as no subnets present for load balancer creation", func(*testing.T) {
1459-
g := NewWithT(t)
1460-
setup(t)
1461-
t.Cleanup(teardown)
1462-
1463-
clusterScope := PowerVSClusterScope{
1464-
IBMVPCClient: mockVpc,
1465-
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{
1466-
Spec: infrav1beta2.IBMPowerVSClusterSpec{
1467-
ResourceGroup: &infrav1beta2.IBMPowerVSResourceReference{
1468-
ID: ptr.To("test-resource-gid"),
1469-
},
1470-
LoadBalancers: []infrav1beta2.VPCLoadBalancerSpec{
1471-
{
1472-
Name: "test-lb",
1473-
ID: nil,
1474-
},
1475-
},
1476-
},
1477-
},
1478-
}
1479-
1480-
mockVpc.EXPECT().GetLoadBalancerByName(gomock.Any()).Return(nil, nil)
1481-
1482-
requeue, err := clusterScope.ReconcileLoadBalancers()
1483-
g.Expect(requeue).To(BeFalse())
1484-
g.Expect(err).ToNot(BeNil())
1485-
})
1486-
1487-
t.Run("When IBMVPCClient client CreateLoadBalancer returns error due to failed loadBalancer creation in cloud", func(*testing.T) {
1429+
t.Run("When createLoadBalancer fails to create load balancer", func(*testing.T) {
14881430
g := NewWithT(t)
14891431
setup(t)
14901432
t.Cleanup(teardown)
@@ -1530,12 +1472,12 @@ func TestReconcileLoadBalancers(t *testing.T) {
15301472

15311473
mockVpc.EXPECT().GetLoadBalancerByName(gomock.Any()).Return(nil, nil)
15321474
mockVpc.EXPECT().CreateLoadBalancer(gomock.Any()).Return(nil, nil, errors.New("failed loadBalancer creation"))
1533-
requeue, err := clusterScope.ReconcileLoadBalancers()
1534-
g.Expect(requeue).To(BeFalse())
1475+
loadBalancerReady, err := clusterScope.ReconcileLoadBalancers()
1476+
g.Expect(loadBalancerReady).To(BeFalse())
15351477
g.Expect(err).ToNot(BeNil())
15361478
})
15371479

1538-
t.Run("When IBMVPCClient client CreateLoadBalancer successfully creates loadbalancer in cloud", func(*testing.T) {
1480+
t.Run("When createLoadBalancer successfully creates load balancer", func(*testing.T) {
15391481
g := NewWithT(t)
15401482
setup(t)
15411483
t.Cleanup(teardown)
@@ -1586,8 +1528,8 @@ func TestReconcileLoadBalancers(t *testing.T) {
15861528
Hostname: ptr.To("test-lb-hostname"),
15871529
}, nil, nil)
15881530

1589-
requeue, err := clusterScope.ReconcileLoadBalancers()
1590-
g.Expect(requeue).To(BeFalse())
1531+
loadBalancerReady, err := clusterScope.ReconcileLoadBalancers()
1532+
g.Expect(loadBalancerReady).To(BeFalse())
15911533
g.Expect(err).To(BeNil())
15921534

15931535
loadBalancer, ok := clusterScope.IBMPowerVSCluster.Status.LoadBalancers["test-lb"]
@@ -1642,8 +1584,8 @@ func TestCreateLoadbalancer(t *testing.T) {
16421584
},
16431585
}
16441586

1645-
lbStatus, err := clusterScope.createLoadBalancer(lb)
1646-
g.Expect(lbStatus).To(BeNil())
1587+
loadBalancerStatus, err := clusterScope.createLoadBalancer(lb)
1588+
g.Expect(loadBalancerStatus).To(BeNil())
16471589
g.Expect(err).ToNot(BeNil())
16481590
})
16491591

@@ -1678,8 +1620,8 @@ func TestCreateLoadbalancer(t *testing.T) {
16781620
},
16791621
}
16801622

1681-
lbStatus, err := clusterScope.createLoadBalancer(lb)
1682-
g.Expect(lbStatus).To(BeNil())
1623+
loadbalancerStatus, err := clusterScope.createLoadBalancer(lb)
1624+
g.Expect(loadbalancerStatus).To(BeNil())
16831625
g.Expect(err).ToNot(BeNil())
16841626
})
16851627

@@ -1737,8 +1679,8 @@ func TestCreateLoadbalancer(t *testing.T) {
17371679
}
17381680

17391681
mockVpc.EXPECT().CreateLoadBalancer(gomock.Any()).Return(nil, nil, errors.New("failed loadBalancer creation"))
1740-
loadBalancer, err := clusterScope.createLoadBalancer(lb)
1741-
g.Expect(loadBalancer).To(BeNil())
1682+
loadBalancerStatus, err := clusterScope.createLoadBalancer(lb)
1683+
g.Expect(loadBalancerStatus).To(BeNil())
17421684
g.Expect(err).ToNot(BeNil())
17431685
})
17441686

@@ -1801,11 +1743,11 @@ func TestCreateLoadbalancer(t *testing.T) {
18011743
Hostname: ptr.To("test-lb-hostname"),
18021744
}, nil, nil)
18031745

1804-
loadBalancer, err := clusterScope.createLoadBalancer(lb)
1746+
loadBalancerStatus, err := clusterScope.createLoadBalancer(lb)
18051747
g.Expect(err).To(BeNil())
1806-
g.Expect(loadBalancer.State).To(BeEquivalentTo(infrav1beta2.VPCLoadBalancerStateActive))
1807-
g.Expect(loadBalancer.ControllerCreated).To(Equal(ptr.To(true)))
1808-
g.Expect(loadBalancer.Hostname).To(Equal(ptr.To("test-lb-hostname")))
1748+
g.Expect(loadBalancerStatus.State).To(BeEquivalentTo(infrav1beta2.VPCLoadBalancerStateActive))
1749+
g.Expect(loadBalancerStatus.ControllerCreated).To(Equal(ptr.To(true)))
1750+
g.Expect(loadBalancerStatus.Hostname).To(Equal(ptr.To("test-lb-hostname")))
18091751
})
18101752
}
18111753

@@ -1897,8 +1839,8 @@ func TestCheckLoadBalancer(t *testing.T) {
18971839
}
18981840

18991841
mockVpc.EXPECT().GetLoadBalancerByName(gomock.Any()).Return(nil, errors.New("failed to get load balancer by name"))
1900-
loadbalancer, err := clusterScope.checkLoadBalancer(lb)
1901-
g.Expect(loadbalancer).To(BeNil())
1842+
loadBalancerStatus, err := clusterScope.checkLoadBalancer(lb)
1843+
g.Expect(loadBalancerStatus).To(BeNil())
19021844
g.Expect(err).ToNot(BeNil())
19031845
})
19041846

@@ -1926,8 +1868,8 @@ func TestCheckLoadBalancer(t *testing.T) {
19261868

19271869
mockVpc.EXPECT().GetLoadBalancerByName(gomock.Any()).Return(nil, nil)
19281870

1929-
loadbalancer, err := clusterScope.checkLoadBalancer(lb)
1930-
g.Expect(loadbalancer).To(BeNil())
1871+
loadBalancerStatus, err := clusterScope.checkLoadBalancer(lb)
1872+
g.Expect(loadBalancerStatus).To(BeNil())
19311873
g.Expect(err).To(BeNil())
19321874
})
19331875

@@ -1961,11 +1903,11 @@ func TestCheckLoadBalancer(t *testing.T) {
19611903
Name: "test-lb",
19621904
}
19631905

1964-
loadbalancer, err := clusterScope.checkLoadBalancer(lb)
1906+
loadBalancerStatus, err := clusterScope.checkLoadBalancer(lb)
19651907
g.Expect(err).To(BeNil())
1966-
g.Expect(loadbalancer.ID).To(Equal(ptr.To("test-lb-instanceid")))
1967-
g.Expect(loadbalancer.State).To(Equal(infrav1beta2.VPCLoadBalancerStateActive))
1968-
g.Expect(loadbalancer.Hostname).To(Equal(ptr.To("test-lb-hostname")))
1908+
g.Expect(loadBalancerStatus.ID).To(Equal(ptr.To("test-lb-instanceid")))
1909+
g.Expect(loadBalancerStatus.State).To(Equal(infrav1beta2.VPCLoadBalancerStateActive))
1910+
g.Expect(loadBalancerStatus.Hostname).To(Equal(ptr.To("test-lb-hostname")))
19691911
})
19701912
}
19711913

@@ -1996,8 +1938,8 @@ func TestCheckLoadBalancerStatus(t *testing.T) {
19961938
g := NewWithT(t)
19971939
clusterScope := PowerVSClusterScope{}
19981940
t.Run(tc.name, func(_ *testing.T) {
1999-
status := clusterScope.checkLoadBalancerStatus(tc.loadbalancer)
2000-
g.Expect(status).To(Equal(tc.expectedStatus))
1941+
isReady := clusterScope.checkLoadBalancerStatus(tc.loadbalancer)
1942+
g.Expect(isReady).To(Equal(tc.expectedStatus))
20011943
})
20021944
}
20031945
}

0 commit comments

Comments
 (0)