Runs locally. Fingers crossed.

Author: Joshua Reed

test/helpers/client.go

@@ -0,0 +1,25 @@
+package helpers
+
+import (
+	"os"
+
+	"github.com/apache/cloudstack-go/v2/cloudstack"
+	"github.com/aws/cluster-api-provider-cloudstack/pkg/cloud"
+	"github.com/pkg/errors"
+	"gopkg.in/ini.v1"
+)
+
+func NewCSClient() (*cloudstack.CloudStackClient, error) {
+	projDir := os.Getenv("PROJECT_DIR")
+	conf := cloud.Config{}
+	ccPath := projDir + "/cloud-config"
+	if rawCfg, err := ini.Load(ccPath); err != nil {
+		return nil, errors.Wrapf(err, "reading config at path %s:", ccPath)
+	} else if g := rawCfg.Section("Global"); len(g.Keys()) == 0 {
+		return nil, errors.New("section Global not found")
+	} else if err = rawCfg.Section("Global").StrictMapTo(&conf); err != nil {
+		return nil, errors.Wrapf(err, "parsing [Global] section from config at path %s:", ccPath)
+	}
+	csClient := cloudstack.NewAsyncClient(conf.APIURL, conf.APIKey, conf.SecretKey, conf.VerifySSL)
+	return csClient, nil
+}

test/helpers/user.go

@@ -8,7 +8,7 @@ import (
 	"github.com/aws/cluster-api-provider-cloudstack/pkg/cloud"
 )
 
-const tempUserName = "TemporaryUser"
+const TempUserName = "TemporaryUser"
 
 // GetDomainByPath fetches a domain by its path.
 func GetDomainByPath(csClient *cloudstack.CloudStackClient, path string) (string, error, bool) {
@@ -134,7 +134,7 @@ func GetOrCreateAccount(csClient *cloudstack.CloudStackClient, account *cloud.Ac
 		return fmt.Errorf("expected exactly one role with name 'Domain Admin', found %d", count)
 	}
 
-	p := csClient.Account.NewCreateAccountParams("[email protected]", "first", "last", "temp123", tempUserName)
+	p := csClient.Account.NewCreateAccountParams("[email protected]", "first", "last", "temp123", TempUserName)
 	p.SetDomainid(account.Domain.ID)
 	p.SetRoleid(roleDetails.Id)
 	resp, err := csClient.Account.CreateAccount(p)

test/helpers/user_test.go

@@ -17,27 +17,15 @@ limitations under the License.
 package helpers_test
 
 import (
-	"github.com/apache/cloudstack-go/v2/cloudstack"
 	"github.com/aws/cluster-api-provider-cloudstack/pkg/cloud"
 	"github.com/aws/cluster-api-provider-cloudstack/test/helpers"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	"github.com/pkg/errors"
-	"gopkg.in/ini.v1"
 )
 
 var _ = Describe("Test helper methods", func() {
-	var csClient *cloudstack.CloudStackClient
-	ccPath := "../../cloud-config"
-	conf := cloud.Config{}
-	if rawCfg, err := ini.Load("../../cloud-config"); err != nil {
-		Ω(errors.Wrapf(err, "reading config at path %s:", ccPath)).ShouldNot(HaveOccurred())
-	} else if g := rawCfg.Section("Global"); len(g.Keys()) == 0 {
-		Ω(errors.New("section Global not found")).ShouldNot(HaveOccurred())
-	} else if err = rawCfg.Section("Global").StrictMapTo(&conf); err != nil {
-		Ω(errors.Wrapf(err, "parsing [Global] section from config at path %s:", ccPath)).ShouldNot(HaveOccurred())
-	}
-	csClient = cloudstack.NewAsyncClient(conf.APIURL, conf.APIKey, conf.SecretKey, conf.VerifySSL)
+	csClient, err := helpers.NewCSClient()
+	Ω(err).ShouldNot(HaveOccurred())
 
 	// Get the root domain's ID.
 	rootDomainID, err, found := helpers.GetDomainByPath(csClient, "ROOT/")

test/unit/cloud/cloud_suite_test.go

@@ -23,23 +23,53 @@ import (
 	"github.com/apache/cloudstack-go/v2/cloudstack"
 	"github.com/aws/cluster-api-provider-cloudstack-staging/test/unit/dummies"
 	"github.com/aws/cluster-api-provider-cloudstack/pkg/cloud"
+	"github.com/aws/cluster-api-provider-cloudstack/test/helpers"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
+	"k8s.io/apimachinery/pkg/util/uuid"
 )
 
 var (
 	realCloudClient cloud.Client
 	client          cloud.Client
 	realCSClient    *cloudstack.CloudStackClient
+	testDomainPath  string // Needed in before and in after suite.
 )
 
 var _ = BeforeSuite(func() {
+	// Create a real cloud client.
 	projDir := os.Getenv("PROJECT_DIR")
 	var connectionErr error
 	realCloudClient, connectionErr = cloud.NewClient(projDir + "/cloud-config")
 	Ω(connectionErr).ShouldNot(HaveOccurred())
 
-	Ω().Should(Succeed())
+	// Create a real CloudStack client.
+	realCSClient, connectionErr = helpers.NewCSClient()
+	Ω(connectionErr).ShouldNot(HaveOccurred())
+
+	// Create a new account and user to run tests that use a real ACS instance.
+	uid := string(uuid.NewUUID())
+	newAccount := cloud.Account{
+		Name:   "TestAccount-" + uid,
+		Domain: cloud.Domain{Name: "TestDomain-" + uid, Path: "ROOT/TestDomain-" + uid}}
+	newUser := cloud.User{Account: newAccount}
+	Ω(helpers.GetOrCreateUserWithKey(realCSClient, &newUser)).Should(Succeed())
+	testDomainPath = newAccount.Domain.Path
+
+	Ω(newUser.APIKey).ShouldNot(BeEmpty())
+
+	// Switch to test account user.
+	cfg := cloud.Config{APIKey: newUser.APIKey, SecretKey: newUser.SecretKey}
+	realCloudClient, connectionErr = realCloudClient.NewClientFromSpec(cfg)
+	Ω(connectionErr).ShouldNot(HaveOccurred())
+})
+
+var _ = AfterSuite(func() {
+	// Delete created domain.
+	id, err, found := helpers.GetDomainByPath(realCSClient, testDomainPath)
+	Ω(err).ShouldNot(HaveOccurred())
+	Ω(found).Should(BeTrue())
+	Ω(helpers.DeleteDomain(realCSClient, id)).Should(Succeed())
 })
 
 func TestCloud(t *testing.T) {
@@ -49,10 +79,10 @@ func TestCloud(t *testing.T) {
 
 // FetchIntegTestResources runs through basic CloudStack Client setup methods needed to test others.
 func FetchIntegTestResources() {
-	Ω(client.ResolveZone(dummies.CSZone1)).Should(Succeed())
+	realCloudClient.ResolveZone(dummies.CSZone1)
 	Ω(dummies.CSZone1.Spec.ID).ShouldNot(BeEmpty())
 	dummies.CSMachine1.Status.ZoneID = dummies.CSZone1.Spec.ID
 	dummies.CSMachine1.Spec.DiskOffering.Name = ""
 	dummies.CSCluster.Spec.ControlPlaneEndpoint.Host = ""
-	Ω(client.GetOrCreateIsolatedNetwork(dummies.CSZone1, dummies.CSISONet1, dummies.CSCluster)).Should(Succeed())
+	Ω(realCloudClient.GetOrCreateIsolatedNetwork(dummies.CSZone1, dummies.CSISONet1, dummies.CSCluster)).Should(Succeed())
 }

test/unit/cloud/isolated_network_test.go

@@ -213,9 +213,7 @@ var _ = Describe("Network", func() {
 			dummies.CSZone1.Spec.ID = ""                          // Make CAPC methods resolve this.
 			dummies.CSCluster.Status.Zones = capcv1.ZoneStatusMap{}
 
-			// Get Zone info needed for network testing.
-			Ω(client.ResolveZone(dummies.CSZone1)).Should(Succeed())
-			dummies.CSISONet1.Spec.ID = ""
+			FetchIntegTestResources()
 		})
 
 		It("fetches an isolated network", func() {
@@ -238,8 +236,10 @@ var _ = Describe("Network", func() {
 		It("adds an isolated network and doesn't fail when asked to GetOrCreateIsolatedNetwork multiple times", func() {
 			Ω(client.GetOrCreateIsolatedNetwork(dummies.CSZone1, dummies.CSISONet1, dummies.CSCluster)).Should(Succeed())
 			Ω(client.GetOrCreateIsolatedNetwork(dummies.CSZone1, dummies.CSISONet1, dummies.CSCluster)).Should(Succeed())
+
 			// Network should now exist if it didn't at the start.
 			Ω(client.ResolveNetwork(&dummies.ISONet1)).Should(Succeed())
+
 			// Do once more.
 			Ω(client.GetOrCreateIsolatedNetwork(dummies.CSZone1, dummies.CSISONet1, dummies.CSCluster)).Should(Succeed())
 		})

test/unit/cloud/user_credentials_test.go

@@ -19,6 +19,7 @@ package cloud_test
 import (
 	"github.com/aws/cluster-api-provider-cloudstack-staging/test/unit/dummies"
 	"github.com/aws/cluster-api-provider-cloudstack/pkg/cloud"
+	"github.com/aws/cluster-api-provider-cloudstack/test/helpers"
 	. "github.com/onsi/ginkgo/v2"
 
 	. "github.com/onsi/gomega"
@@ -43,11 +44,9 @@ var _ = Describe("User Credentials", func() {
 		BeforeEach(func() {
 			client = realCloudClient
 
-			// Setup dummies.
-			// TODO: move these to the test dummies package.
-			domain = cloud.Domain{Path: "ROOT/blah/blah/subsub"}
-			account = cloud.Account{Name: "SuperNested", Domain: domain}
-			user = cloud.User{Name: "SubSub", Account: account}
+			domain = cloud.Domain{Path: testDomainPath}
+			account = cloud.Account{Domain: domain}
+			user = cloud.User{Name: helpers.TempUserName, Account: account}
 		})
 
 		It("can resolve a domain from the path", func() {