Skip to content

Commit 90a8d87

Browse files
Shilpa-GokulShilpa-Gokul
committed
Add UT for ReconcileNetwork function
1 parent cfbfcd4 commit 90a8d87

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"
@@ -1704,3 +1706,326 @@ func TestCreateServiceInstance(t *testing.T) {
17041706
g.Expect(err).To(BeNil())
17051707
})
17061708
}
1709+
1710+
func TestIsDHCPServerActive(t *testing.T) {
1711+
var (
1712+
mockPowerVS *mockP.MockPowerVS
1713+
mockCtrl *gomock.Controller
1714+
)
1715+
1716+
setup := func(t *testing.T) {
1717+
t.Helper()
1718+
mockCtrl = gomock.NewController(t)
1719+
mockPowerVS = mockP.NewMockPowerVS(mockCtrl)
1720+
}
1721+
teardown := func() {
1722+
mockCtrl.Finish()
1723+
}
1724+
1725+
t.Run("When GetDHCPServer returns error", func(t *testing.T) {
1726+
g := NewWithT(t)
1727+
setup(t)
1728+
t.Cleanup(teardown)
1729+
clusterScope := PowerVSClusterScope{
1730+
IBMPowerVSClient: mockPowerVS,
1731+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Status: infrav1beta2.IBMPowerVSClusterStatus{DHCPServer: &infrav1beta2.ResourceReference{ID: ptr.To("dhcpID")}}},
1732+
}
1733+
mockPowerVS.EXPECT().GetDHCPServer(gomock.Any()).Return(nil, fmt.Errorf("GetDHCPServer returns error"))
1734+
isActive, err := clusterScope.isDHCPServerActive()
1735+
g.Expect(err).ToNot(BeNil())
1736+
g.Expect(isActive).To(BeFalse())
1737+
})
1738+
t.Run("When checkDHCPServerStatus returns error state", func(t *testing.T) {
1739+
g := NewWithT(t)
1740+
setup(t)
1741+
t.Cleanup(teardown)
1742+
1743+
dhcpServer := &models.DHCPServerDetail{ID: ptr.To("dhcpID"), Status: ptr.To(string(infrav1beta2.DHCPServerStateError))}
1744+
clusterScope := PowerVSClusterScope{
1745+
IBMPowerVSClient: mockPowerVS,
1746+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Status: infrav1beta2.IBMPowerVSClusterStatus{DHCPServer: &infrav1beta2.ResourceReference{ID: ptr.To("dhcpID")}}},
1747+
}
1748+
mockPowerVS.EXPECT().GetDHCPServer(gomock.Any()).Return(dhcpServer, nil)
1749+
1750+
isActive, err := clusterScope.isDHCPServerActive()
1751+
g.Expect(err).ToNot(BeNil())
1752+
g.Expect(isActive).To(BeFalse())
1753+
})
1754+
t.Run("When checkDHCPServerStatus returns active state", func(t *testing.T) {
1755+
g := NewWithT(t)
1756+
setup(t)
1757+
t.Cleanup(teardown)
1758+
1759+
dhcpServer := &models.DHCPServerDetail{ID: ptr.To("dhcpID"), Status: ptr.To(string(infrav1beta2.DHCPServerStateActive))}
1760+
clusterScope := PowerVSClusterScope{
1761+
IBMPowerVSClient: mockPowerVS,
1762+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Status: infrav1beta2.IBMPowerVSClusterStatus{DHCPServer: &infrav1beta2.ResourceReference{ID: ptr.To("dhcpID")}}},
1763+
}
1764+
mockPowerVS.EXPECT().GetDHCPServer(gomock.Any()).Return(dhcpServer, nil)
1765+
1766+
isActive, err := clusterScope.isDHCPServerActive()
1767+
g.Expect(err).To(BeNil())
1768+
g.Expect(isActive).To(BeTrue())
1769+
})
1770+
}
1771+
1772+
func TestCheckDHCPServerStatus(t *testing.T) {
1773+
testCases := []struct {
1774+
name string
1775+
dhcpServer models.DHCPServerDetail
1776+
expectedStatus bool
1777+
}{
1778+
{
1779+
name: "DHCP server is in build state",
1780+
dhcpServer: models.DHCPServerDetail{ID: ptr.To("dhcpIDBuild"), Status: ptr.To(string(infrav1beta2.DHCPServerStateBuild))},
1781+
expectedStatus: false,
1782+
},
1783+
{
1784+
name: "DHCP server is in active state",
1785+
dhcpServer: models.DHCPServerDetail{ID: ptr.To("dhcpIDActive"), Status: ptr.To(string(infrav1beta2.DHCPServerStateActive))},
1786+
expectedStatus: true,
1787+
},
1788+
{
1789+
name: "DHCP server is in error state",
1790+
dhcpServer: models.DHCPServerDetail{ID: ptr.To("dhcpIDError"), Status: ptr.To(string(infrav1beta2.DHCPServerStateError))},
1791+
expectedStatus: false,
1792+
},
1793+
{
1794+
name: "DHCP server is in invalid state",
1795+
dhcpServer: models.DHCPServerDetail{ID: ptr.To("dhcpIDError"), Status: ptr.To("InvalidState")},
1796+
expectedStatus: false,
1797+
},
1798+
}
1799+
for _, tc := range testCases {
1800+
g := NewWithT(t)
1801+
clusterScope := PowerVSClusterScope{}
1802+
t.Run(tc.name, func(_ *testing.T) {
1803+
status, _ := clusterScope.checkDHCPServerStatus(tc.dhcpServer)
1804+
g.Expect(status).To(Equal(tc.expectedStatus))
1805+
})
1806+
}
1807+
}
1808+
1809+
func TestCreateDHCPServer(t *testing.T) {
1810+
var (
1811+
mockPowerVS *mockP.MockPowerVS
1812+
mockCtrl *gomock.Controller
1813+
clusterName = "clusterName"
1814+
)
1815+
1816+
setup := func(t *testing.T) {
1817+
t.Helper()
1818+
mockCtrl = gomock.NewController(t)
1819+
mockPowerVS = mockP.NewMockPowerVS(mockCtrl)
1820+
}
1821+
teardown := func() {
1822+
mockCtrl.Finish()
1823+
}
1824+
1825+
t.Run("When dhcpServerDetails is empty", func(t *testing.T) {
1826+
g := NewWithT(t)
1827+
setup(t)
1828+
t.Cleanup(teardown)
1829+
1830+
dhcpNetwork := &models.DHCPServerNetwork{ID: ptr.To("dhcpNetworkID")}
1831+
dhcpServer := &models.DHCPServer{ID: ptr.To("dhcpID"), Network: dhcpNetwork}
1832+
clusterScope := PowerVSClusterScope{
1833+
IBMPowerVSClient: mockPowerVS,
1834+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{ObjectMeta: metav1.ObjectMeta{Name: clusterName}},
1835+
}
1836+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(dhcpServer, nil)
1837+
dhcpID, err := clusterScope.createDHCPServer()
1838+
g.Expect(dhcpID).To(Equal(dhcpServer.ID))
1839+
g.Expect(err).To(BeNil())
1840+
g.Expect(clusterScope.IBMPowerVSCluster.Status.Network.ID).To(Equal(dhcpNetwork.ID))
1841+
})
1842+
1843+
t.Run("When dhcpServerDetails are all set but createDHCPServer returns server with no network", func(t *testing.T) {
1844+
g := NewWithT(t)
1845+
setup(t)
1846+
t.Cleanup(teardown)
1847+
1848+
dhcpServer := &models.DHCPServer{ID: ptr.To("dhcpID")}
1849+
clusterScope := PowerVSClusterScope{
1850+
IBMPowerVSClient: mockPowerVS,
1851+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{
1852+
ObjectMeta: metav1.ObjectMeta{Name: clusterName},
1853+
Spec: infrav1beta2.IBMPowerVSClusterSpec{DHCPServer: &infrav1beta2.DHCPServer{
1854+
ID: ptr.To("dhcpID"),
1855+
DNSServer: ptr.To("DNSServer"),
1856+
Cidr: ptr.To("10.10.1.10/24"),
1857+
Snat: ptr.To(true),
1858+
}},
1859+
},
1860+
}
1861+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(dhcpServer, nil)
1862+
dhcpID, err := clusterScope.createDHCPServer()
1863+
g.Expect(dhcpID).To(BeNil())
1864+
g.Expect(err).ToNot(BeNil())
1865+
})
1866+
1867+
t.Run("When dhcpServerDetails has no dnsserver,cidr or snat set", func(t *testing.T) {
1868+
g := NewWithT(t)
1869+
setup(t)
1870+
t.Cleanup(teardown)
1871+
1872+
dhcpNetwork := &models.DHCPServerNetwork{ID: ptr.To("dhcpNetworkID")}
1873+
dhcpServer := &models.DHCPServer{ID: ptr.To("dhcpID"), Network: dhcpNetwork}
1874+
clusterScope := PowerVSClusterScope{
1875+
IBMPowerVSClient: mockPowerVS,
1876+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{ObjectMeta: metav1.ObjectMeta{Name: clusterName}},
1877+
}
1878+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(dhcpServer, nil)
1879+
dhcpID, err := clusterScope.createDHCPServer()
1880+
g.Expect(dhcpID).To(Equal(dhcpServer.ID))
1881+
g.Expect(err).To(BeNil())
1882+
g.Expect(clusterScope.IBMPowerVSCluster.Status.Network.ID).To(Equal(dhcpNetwork.ID))
1883+
})
1884+
1885+
t.Run("When CreateDHCPServer returns empty dhcp server", func(t *testing.T) {
1886+
g := NewWithT(t)
1887+
setup(t)
1888+
t.Cleanup(teardown)
1889+
1890+
clusterScope := PowerVSClusterScope{
1891+
IBMPowerVSClient: mockPowerVS,
1892+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{ObjectMeta: metav1.ObjectMeta{Name: clusterName}},
1893+
}
1894+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(nil, nil)
1895+
dhcpID, err := clusterScope.createDHCPServer()
1896+
g.Expect(dhcpID).To(BeNil())
1897+
g.Expect(err).ToNot(BeNil())
1898+
})
1899+
1900+
t.Run("When CreateDHCPServer returns error", func(t *testing.T) {
1901+
g := NewWithT(t)
1902+
setup(t)
1903+
t.Cleanup(teardown)
1904+
1905+
clusterScope := PowerVSClusterScope{
1906+
IBMPowerVSClient: mockPowerVS,
1907+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{ObjectMeta: metav1.ObjectMeta{Name: clusterName}},
1908+
}
1909+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(nil, fmt.Errorf("CreateDHCPServer returns error"))
1910+
dhcpID, err := clusterScope.createDHCPServer()
1911+
g.Expect(dhcpID).To(BeNil())
1912+
g.Expect(err).ToNot(BeNil())
1913+
})
1914+
}
1915+
1916+
func TestReconcileNetwork(t *testing.T) {
1917+
var (
1918+
mockPowerVS *mockP.MockPowerVS
1919+
mockCtrl *gomock.Controller
1920+
)
1921+
1922+
setup := func(t *testing.T) {
1923+
t.Helper()
1924+
mockCtrl = gomock.NewController(t)
1925+
mockPowerVS = mockP.NewMockPowerVS(mockCtrl)
1926+
}
1927+
teardown := func() {
1928+
mockCtrl.Finish()
1929+
}
1930+
t.Run("When GetDHCPServer returns error", func(t *testing.T) {
1931+
g := NewWithT(t)
1932+
setup(t)
1933+
t.Cleanup(teardown)
1934+
1935+
clusterScope := PowerVSClusterScope{
1936+
IBMPowerVSClient: mockPowerVS,
1937+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Status: infrav1beta2.IBMPowerVSClusterStatus{DHCPServer: &infrav1beta2.ResourceReference{ID: ptr.To("dhcpID")}}},
1938+
}
1939+
mockPowerVS.EXPECT().GetDHCPServer(gomock.Any()).Return(nil, fmt.Errorf("GetDHCPServer error"))
1940+
1941+
requeue, err := clusterScope.ReconcileNetwork()
1942+
g.Expect(err).ToNot(BeNil())
1943+
g.Expect(requeue).To(BeFalse())
1944+
})
1945+
t.Run("When DHCPServer exists and is active", func(t *testing.T) {
1946+
g := NewWithT(t)
1947+
setup(t)
1948+
t.Cleanup(teardown)
1949+
1950+
clusterScope := PowerVSClusterScope{
1951+
IBMPowerVSClient: mockPowerVS,
1952+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Status: infrav1beta2.IBMPowerVSClusterStatus{DHCPServer: &infrav1beta2.ResourceReference{ID: ptr.To("dhcpID")}}},
1953+
}
1954+
1955+
dhcpServer := &models.DHCPServerDetail{ID: ptr.To("dhcpID"), Status: ptr.To(string(infrav1beta2.DHCPServerStateActive))}
1956+
mockPowerVS.EXPECT().GetDHCPServer(gomock.Any()).Return(dhcpServer, nil)
1957+
1958+
requeue, err := clusterScope.ReconcileNetwork()
1959+
g.Expect(err).To(BeNil())
1960+
g.Expect(requeue).To(BeTrue())
1961+
})
1962+
t.Run("When DHCPID is empty and GetNetworkByID returns error ", func(t *testing.T) {
1963+
g := NewWithT(t)
1964+
setup(t)
1965+
t.Cleanup(teardown)
1966+
1967+
clusterScope := PowerVSClusterScope{
1968+
IBMPowerVSClient: mockPowerVS,
1969+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Spec: infrav1beta2.IBMPowerVSClusterSpec{
1970+
Network: infrav1beta2.IBMPowerVSResourceReference{ID: ptr.To("networkID")}}},
1971+
}
1972+
network := &models.Network{}
1973+
mockPowerVS.EXPECT().GetNetworkByID(gomock.Any()).Return(network, fmt.Errorf("GetNetworkByID error"))
1974+
1975+
requeue, err := clusterScope.ReconcileNetwork()
1976+
g.Expect(err).ToNot(BeNil())
1977+
g.Expect(requeue).To(BeFalse())
1978+
})
1979+
t.Run("When DHCPID is empty and networkID is not empty", func(t *testing.T) {
1980+
g := NewWithT(t)
1981+
setup(t)
1982+
t.Cleanup(teardown)
1983+
network := &models.Network{NetworkID: ptr.To("networkID")}
1984+
clusterScope := PowerVSClusterScope{
1985+
IBMPowerVSClient: mockPowerVS,
1986+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Spec: infrav1beta2.IBMPowerVSClusterSpec{
1987+
Network: infrav1beta2.IBMPowerVSResourceReference{ID: ptr.To("networkID")}}},
1988+
}
1989+
mockPowerVS.EXPECT().GetNetworkByID(gomock.Any()).Return(network, nil)
1990+
requeue, err := clusterScope.ReconcileNetwork()
1991+
g.Expect(clusterScope.IBMPowerVSCluster.Status.Network.ID).To(Equal(network.NetworkID))
1992+
g.Expect(err).To(BeNil())
1993+
g.Expect(requeue).To(BeTrue())
1994+
})
1995+
t.Run("When DHCPID is empty and checkNetwork returns empty network ID", func(t *testing.T) {
1996+
g := NewWithT(t)
1997+
setup(t)
1998+
t.Cleanup(teardown)
1999+
2000+
dhcpNetwork := &models.DHCPServerNetwork{ID: ptr.To("dhcpNetworkID")}
2001+
dhcpServer := &models.DHCPServer{ID: ptr.To("dhcpID"), Network: dhcpNetwork}
2002+
clusterScope := PowerVSClusterScope{
2003+
IBMPowerVSClient: mockPowerVS,
2004+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Spec: infrav1beta2.IBMPowerVSClusterSpec{
2005+
Network: infrav1beta2.IBMPowerVSResourceReference{Name: ptr.To("networkName")}}},
2006+
}
2007+
mockPowerVS.EXPECT().GetNetworkByName(gomock.Any()).Return(nil, nil)
2008+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(dhcpServer, nil)
2009+
requeue, err := clusterScope.ReconcileNetwork()
2010+
g.Expect(clusterScope.IBMPowerVSCluster.Status.DHCPServer.ID).To(Equal(dhcpServer.ID))
2011+
g.Expect(clusterScope.IBMPowerVSCluster.Status.Network.ID).To(Equal(dhcpNetwork.ID))
2012+
g.Expect(err).To(BeNil())
2013+
g.Expect(requeue).To(BeFalse())
2014+
})
2015+
t.Run("When DHCPID and networkID is not empty and createDHCPServer returns error", func(t *testing.T) {
2016+
g := NewWithT(t)
2017+
setup(t)
2018+
t.Cleanup(teardown)
2019+
2020+
clusterScope := PowerVSClusterScope{
2021+
IBMPowerVSClient: mockPowerVS,
2022+
IBMPowerVSCluster: &infrav1beta2.IBMPowerVSCluster{Spec: infrav1beta2.IBMPowerVSClusterSpec{
2023+
Network: infrav1beta2.IBMPowerVSResourceReference{Name: ptr.To("networkName")}}},
2024+
}
2025+
mockPowerVS.EXPECT().GetNetworkByName(gomock.Any()).Return(nil, nil)
2026+
mockPowerVS.EXPECT().CreateDHCPServer(gomock.Any()).Return(nil, fmt.Errorf("CreateDHCPServer error"))
2027+
requeue, err := clusterScope.ReconcileNetwork()
2028+
g.Expect(err).ToNot(BeNil())
2029+
g.Expect(requeue).To(BeFalse())
2030+
})
2031+
}

0 commit comments

Comments
 (0)