Network test for shared case is working.

Author: Joshua Reed

pkg/cloud/cluster.go

@@ -91,6 +91,10 @@ func (c *client) GetOrCreateCluster(csCluster *infrav1.CloudStackCluster) (retEr
 		return c.GetOrCreateIsolatedNetwork(csCluster)
 	}
 
+	// TODO: Make this tag all networks as in use. Didn't make sense in resolveNetworks.
+	// if err := c.AddClusterTag(ResourceTypeNetwork, zoneStatus.Network.ID, csCluster, doNotAddCreatedByTag); err != nil {
+	// }
+
 	return nil
 }
 

pkg/cloud/instance.go

@@ -145,7 +145,7 @@ func (c *client) GetOrCreateVMInstance(
 
 	zone, ok := csCluster.Status.Zones[*capiMachine.Spec.FailureDomain]
 	if !ok {
-		return errors.New("FailureDomain zone not found.")
+		return errors.New("failureDomain zone not found")
 	}
 
 	// Check if VM instance already exists.

pkg/cloud/network.go

@@ -29,7 +29,7 @@ import (
 type NetworkIface interface {
 	ResolveNetworkStatuses(*infrav1.CloudStackCluster) error
 	ResolveNetwork(*infrav1.CloudStackCluster, *infrav1.Network) error
-	CreateIsolatedNewtork(*infrav1.CloudStackCluster) error
+	CreateIsolatedNetwork(*infrav1.CloudStackCluster) error
 	OpenFirewallRules(*infrav1.CloudStackCluster) error
 	ResolvePublicIPDetails(*infrav1.CloudStackCluster) (*cloudstack.PublicIpAddress, error)
 	ResolveLoadBalancerRuleDetails(*infrav1.CloudStackCluster) error
@@ -118,9 +118,9 @@ func (c *client) getOfferingID() (string, error) {
 	return offeringID, nil
 }
 
-// CreateIsolatedNewtork creates an isolated network in the relevant Zone.
+// CreateIsolatedNetwork creates an isolated network in the relevant Zone.
 // Assumes that there is only the one zone in the cluster.
-func (c *client) CreateIsolatedNewtork(csCluster *infrav1.CloudStackCluster) (retErr error) {
+func (c *client) CreateIsolatedNetwork(csCluster *infrav1.CloudStackCluster) (retErr error) {
 	zoneStatus := csCluster.Status.Zones[csCluster.Spec.Zones[0].Network.Name]
 	netStatus := zoneStatus.Network
 
@@ -155,25 +155,16 @@ func (c *client) CreateIsolatedNewtork(csCluster *infrav1.CloudStackCluster) (re
 func (c *client) ResolveNetworkStatuses(csCluster *infrav1.CloudStackCluster) (retErr error) {
 	// Copy network spec to status in preparation for network resolution or creation.
 	for _, specZone := range csCluster.Spec.Zones {
-		zone, ok := csCluster.Status.Zones[specZone.Name]
-		if !ok {
-			csCluster.Status.Zones[specZone.Name] = specZone
-			zone = specZone
-		}
-		zone.Network = specZone.Network
+		csCluster.Status.Zones[specZone.ID] = specZone
 	}
 
 	// At this point network status should have been populated (copied) from the spec.
-	for zoneName, zoneStatus := range csCluster.Status.Zones {
+	for _, zoneStatus := range csCluster.Status.Zones {
 		if retErr = c.ResolveNetwork(csCluster, &zoneStatus.Network); retErr == nil { // Found network
-			csCluster.Status.Zones[zoneName] = zoneStatus
-			err := c.AddClusterTag(ResourceTypeNetwork, zoneStatus.Network.ID, csCluster, doNotAddCreatedByTag)
-			if err != nil {
-				return err
-			}
+			csCluster.Status.Zones[zoneStatus.ID] = zoneStatus
 		} else if !strings.Contains(retErr.Error(), "No match found") { // Some other error.
 			return retErr
-		} // Network not found, so create it.
+		}
 	}
 
 	return nil
@@ -388,7 +379,7 @@ func (c *client) AssignVMToLoadBalancerRule(csCluster *infrav1.CloudStackCluster
 func (c *client) GetOrCreateIsolatedNetwork(csCluster *infrav1.CloudStackCluster) error {
 	onlyNetStatus := csCluster.Status.Zones[csCluster.Spec.Zones[0].Network.Name].Network
 	if !networkExists(onlyNetStatus) { // create isolated network.
-		if err := c.CreateIsolatedNewtork(csCluster); err != nil {
+		if err := c.CreateIsolatedNetwork(csCluster); err != nil {
 			return err
 		}
 	}

pkg/cloud/network_test.go

@@ -17,50 +17,49 @@ limitations under the License.
 package cloud_test
 
 import (
-	"github.com/apache/cloudstack-go/v2/cloudstack"
-	infrav1 "github.com/aws/cluster-api-provider-cloudstack/api/v1beta1"
+	"fmt"
+
+	csapi "github.com/apache/cloudstack-go/v2/cloudstack"
 	"github.com/aws/cluster-api-provider-cloudstack/pkg/cloud"
 	"github.com/aws/cluster-api-provider-cloudstack/test/dummies"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
-	"github.com/pkg/errors"
 )
 
 var _ = Describe("Network", func() {
 	var ( // Declare shared vars.
 		mockCtrl   *gomock.Controller
-		mockClient *cloudstack.CloudStackClient
-		ns         *cloudstack.MockNetworkServiceIface
-		nos        *cloudstack.MockNetworkOfferingServiceIface
-		fs         *cloudstack.MockFirewallServiceIface
-		as         *cloudstack.MockAddressServiceIface
-		lbs        *cloudstack.MockLoadBalancerServiceIface
-		rs         *cloudstack.MockResourcetagsServiceIface
-		csCluster  *infrav1.CloudStackCluster
-		client     cloud.Client
+		mockClient *csapi.CloudStackClient
+		ns         *csapi.MockNetworkServiceIface
+		// nos        *csapi.MockNetworkOfferingServiceIface
+		// fs         *csapi.MockFirewallServiceIface
+		// as         *csapi.MockAddressServiceIface
+		// lbs        *csapi.MockLoadBalancerServiceIface
+		// rs     *csapi.MockResourcetagsServiceIface
+		client cloud.Client
 	)
 
-	const (
-		fakeNetID           = "fakeNetID"
-		fakeNetName         = "fakeNetName"
-		isolatedNetworkType = "Isolated"
-		lbRuleID            = "lbRuleID"
-		netID               = "someNetID"
-		protocol            = "tcp"
-		publicPort          = "6443"
-	)
+	// const (
+	// 	dummies.Net1.ID           = "dummies.Net1.ID"
+	// 	dummies.Net1.Name         = "dummies.Net1.Name"
+	// 	isolatedNetworkType = "Isolated"
+	// 	lbRuleID            = "lbRuleID"
+	// 	netID               = "someNetID"
+	// 	protocol            = "tcp"
+	// 	publicPort          = "6443"
+	// )
 
 	BeforeEach(func() {
 		// Setup new mock services.
 		mockCtrl = gomock.NewController(GinkgoT())
-		mockClient = cloudstack.NewMockClient(mockCtrl)
-		ns = mockClient.Network.(*cloudstack.MockNetworkServiceIface)
-		nos = mockClient.NetworkOffering.(*cloudstack.MockNetworkOfferingServiceIface)
-		fs = mockClient.Firewall.(*cloudstack.MockFirewallServiceIface)
-		as = mockClient.Address.(*cloudstack.MockAddressServiceIface)
-		lbs = mockClient.LoadBalancer.(*cloudstack.MockLoadBalancerServiceIface)
-		rs = mockClient.Resourcetags.(*cloudstack.MockResourcetagsServiceIface)
+		mockClient = csapi.NewMockClient(mockCtrl)
+		ns = mockClient.Network.(*csapi.MockNetworkServiceIface)
+		// nos = mockClient.NetworkOffering.(*csapi.MockNetworkOfferingServiceIface)
+		// fs = mockClient.Firewall.(*csapi.MockFirewallServiceIface)
+		// as = mockClient.Address.(*csapi.MockAddressServiceIface)
+		// lbs = mockClient.LoadBalancer.(*csapi.MockLoadBalancerServiceIface)
+		// rs = mockClient.Resourcetags.(*csapi.MockResourcetagsServiceIface)
 		client = cloud.NewClientFromCSAPIClient(mockClient)
 		dummies.SetDummyVars()
 	})
@@ -69,128 +68,129 @@ var _ = Describe("Network", func() {
 		mockCtrl.Finish()
 	})
 
-	// Sets expectations network tag creation.  To be used by tests that get/create networks.
-	expectNetworkTags := func(networkID string) {
-		listTagsParams := &cloudstack.ListTagsParams{}
-		createTagsParams := &cloudstack.CreateTagsParams{}
-		rs.EXPECT().NewListTagsParams().Return(listTagsParams)
-		rs.EXPECT().ListTags(listTagsParams).Return(&cloudstack.ListTagsResponse{}, nil)
-		rs.EXPECT().NewCreateTagsParams([]string{networkID}, string(cloud.ResourceTypeNetwork), gomock.Any()).Return(createTagsParams)
-		rs.EXPECT().CreateTags(createTagsParams).Return(&cloudstack.CreateTagsResponse{}, nil)
-	}
+	// // Sets expectations network tag creation.  To be used by tests that get/create networks.
+	// expectNetworkTags := func(networkID string) {
+	// 	listTagsParams := &csapi.ListTagsParams{}
+	// 	createTagsParams := &csapi.CreateTagsParams{}
+	// 	rs.EXPECT().NewListTagsParams().Return(listTagsParams)
+	// 	rs.EXPECT().ListTags(listTagsParams).Return(&csapi.ListTagsResponse{}, nil)
+	// 	rs.EXPECT().NewCreateTagsParams([]string{networkID}, string(cloud.ResourceTypeNetwork), gomock.Any()).Return(createTagsParams)
+	// 	rs.EXPECT().CreateTags(createTagsParams).Return(&csapi.CreateTagsResponse{}, nil)
+	// }
 
 	Context("for an existing network", func() {
-		// It("resolves network details in cluster status", func() {
-		// 	ns.EXPECT().GetNetworkID(fakeNetName).Return(fakeNetID, 1, nil)
-		// 	ns.EXPECT().GetNetworkByID(fakeNetID).Return(&cloudstack.Network{Type: isolatedNetworkType}, 1, nil)
-		// 	Ω(client.ResolveNetwork(csCluster)).Should(Succeed())
-		// 	Ω(csCluster.Status.NetworkID).Should(Equal(fakeNetID))
-		// 	Ω(csCluster.Status.NetworkType).Should(Equal(isolatedNetworkType))
-		// })
-
-		It("does not call to create a new network via GetOrCreateNetwork", func() {
-			ns.EXPECT().GetNetworkID(fakeNetName).Return(fakeNetID, 1, nil)
-			ns.EXPECT().GetNetworkByID(fakeNetID).Return(&cloudstack.Network{Type: isolatedNetworkType}, 1, nil)
-			expectNetworkTags(fakeNetID)
-
-			Ω(client.CreateIsolatedNewtork(dummies.CSCluster)).Should(Succeed())
-		})
+		It("resolves network by ID", func() {
+			ns.EXPECT().GetNetworkByName(dummies.ISONet1.Name).Return(nil, 0, nil)
+			ns.EXPECT().GetNetworkByID(dummies.ISONet1.ID).Return(dummies.CAPCNetToCSAPINet(&dummies.ISONet1), 1, nil)
 
-		It("resolves network details with network ID instead of network name", func() {
-			ns.EXPECT().GetNetworkID(gomock.Any()).Return("", -1, errors.New("no match found for blah"))
-			ns.EXPECT().GetNetworkByID(dummies.Net1.ID).
-				Return(&cloudstack.Network{Name: "TestName", Type: isolatedNetworkType}, 1, nil)
-			expectNetworkTags(dummies.Net1.ID)
-
-			Ω(client.ResolveNetworkStatuses(dummies.CSCluster)).Should(Succeed())
-			Ω(dummies.CSCluster.Status.Zones.GetByName("TestName").Network.Type).Should(Equal(isolatedNetworkType))
+			Ω(client.ResolveNetwork(dummies.CSCluster, &dummies.ISONet1)).Should(Succeed())
 		})
-	})
 
-	Context("for a non-existent network", func() {
-		It("when GetOrCreateNetwork is called it calls CloudStack to create a network", func() {
-			ns.EXPECT().GetNetworkID(gomock.Any()).Return("", -1, errors.New("no match found for blah"))
-			ns.EXPECT().GetNetworkByID(gomock.Any()).Return(nil, -1, errors.New("no match found for blah"))
-			nos.EXPECT().GetNetworkOfferingID(gomock.Any()).Return("someOfferingID", 1, nil)
-			ns.EXPECT().NewCreateNetworkParams(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
-				Return(&cloudstack.CreateNetworkParams{})
-			ns.EXPECT().CreateNetwork(gomock.Any()).Return(&cloudstack.CreateNetworkResponse{Id: dummies.Net1.ID}, nil)
+		It("resolves network by Name", func() {
+			ns.EXPECT().GetNetworkByName(dummies.ISONet1.Name).Return(dummies.CAPCNetToCSAPINet(&dummies.ISONet1), 1, nil)
 
-			expectNetworkTags(dummies.Net1.ID)
-
-			Ω(client.ResolveNetworkStatuses(dummies.CSCluster)).Should(Succeed())
+			Ω(client.ResolveNetwork(dummies.CSCluster, &dummies.ISONet1)).Should(Succeed())
 		})
-	})
+		It("resolves network details in cluster status", func() {
+			// Gets Net1 by Name.
+			ns.EXPECT().GetNetworkByName(dummies.Net1.Name).Return(dummies.CAPCNetToCSAPINet(&dummies.Net1), 1, nil)
 
-	Context("for a closed firewall", func() {
-		It("OpenFirewallRule asks CloudStack to open the firewall", func() {
-			fs.EXPECT().NewCreateEgressFirewallRuleParams(netID, protocol).
-				Return(&cloudstack.CreateEgressFirewallRuleParams{})
-			fs.EXPECT().CreateEgressFirewallRule(&cloudstack.CreateEgressFirewallRuleParams{}).
-				Return(&cloudstack.CreateEgressFirewallRuleResponse{}, nil)
-
-			Ω(client.OpenFirewallRules(csCluster)).Should(Succeed())
-		})
-	})
+			// Trys to get Net2 by name and doesn't find it. Then finds Net2 via ID.
+			ns.EXPECT().GetNetworkByName(dummies.Net2.Name).Return(nil, 0, nil)
+			ns.EXPECT().GetNetworkByID(dummies.Net2.ID).Return(dummies.CAPCNetToCSAPINet(&dummies.Net2), 1, nil)
+			fmt.Println(dummies.CSCluster.Spec.Zones)
 
-	Context("for an open firewall", func() {
-		It("OpenFirewallRule asks CloudStack to open the firewall anyway, but doesn't fail", func() {
-			fs.EXPECT().NewCreateEgressFirewallRuleParams(netID, protocol).
-				Return(&cloudstack.CreateEgressFirewallRuleParams{})
-			fs.EXPECT().CreateEgressFirewallRule(&cloudstack.CreateEgressFirewallRuleParams{}).
-				Return(&cloudstack.CreateEgressFirewallRuleResponse{}, errors.New("there is already a rule like this"))
-			Ω(client.OpenFirewallRules(csCluster)).Should(Succeed())
-		})
-	})
-
-	Context("in an isolated network with public IPs available", func() {
-		It("will resolve public IP details given an endpoint spec", func() {
-			ipAddress := "192.168.1.14"
-			as.EXPECT().NewListPublicIpAddressesParams().Return(&cloudstack.ListPublicIpAddressesParams{})
-			as.EXPECT().ListPublicIpAddresses(gomock.Any()).
-				Return(&cloudstack.ListPublicIpAddressesResponse{
-					Count:             1,
-					PublicIpAddresses: []*cloudstack.PublicIpAddress{{Id: "PublicIPID", Ipaddress: ipAddress}},
-				}, nil)
-			publicIPAddress, err := client.ResolvePublicIPDetails(csCluster)
-			Ω(err).Should(Succeed())
-			Ω(publicIPAddress).ShouldNot(BeNil())
-			Ω(publicIPAddress.Ipaddress).Should(Equal(ipAddress))
-		})
-	})
-
-	Context("The specific load balancer rule does exist", func() {
-		It("resolves the rule's ID", func() {
-			lbs.EXPECT().NewListLoadBalancerRulesParams().Return(&cloudstack.ListLoadBalancerRulesParams{})
-			lbs.EXPECT().ListLoadBalancerRules(gomock.Any()).Return(
-				&cloudstack.ListLoadBalancerRulesResponse{
-					LoadBalancerRules: []*cloudstack.LoadBalancerRule{{Publicport: publicPort, Id: lbRuleID}}}, nil)
-			Ω(client.ResolveLoadBalancerRuleDetails(csCluster)).Should(Succeed())
-			Ω(csCluster.Status.LBRuleID).Should(Equal(lbRuleID))
-		})
-
-		It("doesn't create a new load balancer rule on create", func() {
-			lbs.EXPECT().NewListLoadBalancerRulesParams().Return(&cloudstack.ListLoadBalancerRulesParams{})
-			lbs.EXPECT().ListLoadBalancerRules(gomock.Any()).
-				Return(&cloudstack.ListLoadBalancerRulesResponse{
-					LoadBalancerRules: []*cloudstack.LoadBalancerRule{{Publicport: publicPort, Id: lbRuleID}}}, nil)
-			Ω(client.GetOrCreateLoadBalancerRule(csCluster)).Should(Succeed())
-			Ω(csCluster.Status.LBRuleID).Should(Equal(lbRuleID))
+			Ω(client.ResolveNetworkStatuses(dummies.CSCluster)).Should(Succeed())
+			Ω(dummies.CSCluster.Status.Zones[dummies.Zone1.ID].Network).Should(Equal(dummies.Net1))
+			Ω(dummies.CSCluster.Status.Zones[dummies.Zone2.ID].Network).Should(Equal(dummies.Net2))
 		})
 	})
 
-	Context("load balancer rule does not exist", func() {
-		It("calls cloudstack to create a new load balancer rule.", func() {
-			lbs.EXPECT().NewListLoadBalancerRulesParams().Return(&cloudstack.ListLoadBalancerRulesParams{})
-			lbs.EXPECT().ListLoadBalancerRules(gomock.Any()).Return(&cloudstack.ListLoadBalancerRulesResponse{
-				LoadBalancerRules: []*cloudstack.LoadBalancerRule{{Publicport: "7443", Id: lbRuleID}}}, nil)
-			lbs.EXPECT().NewCreateLoadBalancerRuleParams(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
-				Return(&cloudstack.CreateLoadBalancerRuleParams{})
-			const randomID = "randomID"
-			lbs.EXPECT().CreateLoadBalancerRule(gomock.Any()).
-				Return(&cloudstack.CreateLoadBalancerRuleResponse{Id: randomID}, nil)
-			Ω(client.GetOrCreateLoadBalancerRule(csCluster)).Should(Succeed())
-			Ω(csCluster.Status.LBRuleID).Should(Equal(randomID))
-		})
-	})
+	// Isolated use case only!
+	// Context("for a non-existent network", func() {
+	// 	It("when GetOrCreateNetwork is called it calls CloudStack to create a network", func() {
+	// 		ns.EXPECT().GetNetworkID(gomock.Any()).Return("", -1, errors.New("no match found for blah"))
+	// 		ns.EXPECT().GetNetworkByID(gomock.Any()).Return(nil, -1, errors.New("no match found for blah"))
+	// 		nos.EXPECT().GetNetworkOfferingID(gomock.Any()).Return("someOfferingID", 1, nil)
+	// 		ns.EXPECT().NewCreateNetworkParams(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
+	// 			Return(&csapi.CreateNetworkParams{})
+	// 		ns.EXPECT().CreateNetwork(gomock.Any()).Return(&csapi.CreateNetworkResponse{Id: dummies.Net1.ID}, nil)
+
+	// 		expectNetworkTags(dummies.Net1.ID)
+
+	// 		Ω(client.ResolveNetworkStatuses(dummies.CSCluster)).Should(Succeed())
+	// 	})
+	// })
+
+	// 	Context("for a closed firewall", func() {
+	// 		It("OpenFirewallRule asks CloudStack to open the firewall", func() {
+	// 			fs.EXPECT().NewCreateEgressFirewallRuleParams(netID, protocol).
+	// 				Return(&csapi.CreateEgressFirewallRuleParams{})
+	// 			fs.EXPECT().CreateEgressFirewallRule(&csapi.CreateEgressFirewallRuleParams{}).
+	// 				Return(&csapi.CreateEgressFirewallRuleResponse{}, nil)
+
+	// 			Ω(client.OpenFirewallRules(csCluster)).Should(Succeed())
+	// 		})
+	// 	})
+
+	// 	Context("for an open firewall", func() {
+	// 		It("OpenFirewallRule asks CloudStack to open the firewall anyway, but doesn't fail", func() {
+	// 			fs.EXPECT().NewCreateEgressFirewallRuleParams(netID, protocol).
+	// 				Return(&csapi.CreateEgressFirewallRuleParams{})
+	// 			fs.EXPECT().CreateEgressFirewallRule(&csapi.CreateEgressFirewallRuleParams{}).
+	// 				Return(&csapi.CreateEgressFirewallRuleResponse{}, errors.New("there is already a rule like this"))
+	// 			Ω(client.OpenFirewallRules(csCluster)).Should(Succeed())
+	// 		})
+	// 	})
+
+	// 	Context("in an isolated network with public IPs available", func() {
+	// 		It("will resolve public IP details given an endpoint spec", func() {
+	// 			ipAddress := "192.168.1.14"
+	// 			as.EXPECT().NewListPublicIpAddressesParams().Return(&csapi.ListPublicIpAddressesParams{})
+	// 			as.EXPECT().ListPublicIpAddresses(gomock.Any()).
+	// 				Return(&csapi.ListPublicIpAddressesResponse{
+	// 					Count:             1,
+	// 					PublicIpAddresses: []*csapi.PublicIpAddress{{Id: "PublicIPID", Ipaddress: ipAddress}},
+	// 				}, nil)
+	// 			publicIPAddress, err := client.ResolvePublicIPDetails(csCluster)
+	// 			Ω(err).Should(Succeed())
+	// 			Ω(publicIPAddress).ShouldNot(BeNil())
+	// 			Ω(publicIPAddress.Ipaddress).Should(Equal(ipAddress))
+	// 		})
+	// 	})
+
+	// 	Context("The specific load balancer rule does exist", func() {
+	// 		It("resolves the rule's ID", func() {
+	// 			lbs.EXPECT().NewListLoadBalancerRulesParams().Return(&csapi.ListLoadBalancerRulesParams{})
+	// 			lbs.EXPECT().ListLoadBalancerRules(gomock.Any()).Return(
+	// 				&csapi.ListLoadBalancerRulesResponse{
+	// 					LoadBalancerRules: []*csapi.LoadBalancerRule{{Publicport: publicPort, Id: lbRuleID}}}, nil)
+	// 			Ω(client.ResolveLoadBalancerRuleDetails(csCluster)).Should(Succeed())
+	// 			Ω(csCluster.Status.LBRuleID).Should(Equal(lbRuleID))
+	// 		})
+
+	// 		It("doesn't create a new load balancer rule on create", func() {
+	// 			lbs.EXPECT().NewListLoadBalancerRulesParams().Return(&csapi.ListLoadBalancerRulesParams{})
+	// 			lbs.EXPECT().ListLoadBalancerRules(gomock.Any()).
+	// 				Return(&csapi.ListLoadBalancerRulesResponse{
+	// 					LoadBalancerRules: []*csapi.LoadBalancerRule{{Publicport: publicPort, Id: lbRuleID}}}, nil)
+	// 			Ω(client.GetOrCreateLoadBalancerRule(csCluster)).Should(Succeed())
+	// 			Ω(csCluster.Status.LBRuleID).Should(Equal(lbRuleID))
+	// 		})
+	// 	})
+
+	// 	Context("load balancer rule does not exist", func() {
+	// 		It("calls cloudstack to create a new load balancer rule.", func() {
+	// 			lbs.EXPECT().NewListLoadBalancerRulesParams().Return(&csapi.ListLoadBalancerRulesParams{})
+	// 			lbs.EXPECT().ListLoadBalancerRules(gomock.Any()).Return(&csapi.ListLoadBalancerRulesResponse{
+	// 				LoadBalancerRules: []*csapi.LoadBalancerRule{{Publicport: "7443", Id: lbRuleID}}}, nil)
+	// 			lbs.EXPECT().NewCreateLoadBalancerRuleParams(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
+	// 				Return(&csapi.CreateLoadBalancerRuleParams{})
+	// 			const randomID = "randomID"
+	// 			lbs.EXPECT().CreateLoadBalancerRule(gomock.Any()).
+	// 				Return(&csapi.CreateLoadBalancerRuleResponse{Id: randomID}, nil)
+	// 			Ω(client.GetOrCreateLoadBalancerRule(csCluster)).Should(Succeed())
+	// 			Ω(csCluster.Status.LBRuleID).Should(Equal(randomID))
+	// 		})
+	// 	})
 })