Skip to content

Commit 06a797e

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

File tree

1 file changed

+328
-0
lines changed

1 file changed

+328
-0
lines changed

‎cloud/scope/powervs_cluster_test.go

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

0 commit comments

Comments
 (0)