Moved unit tests to test/unit.

Author: Joshua Reed

Makefile

@@ -171,8 +171,8 @@ export KUBEBUILDER_ASSETS=$(PROJECT_DIR)/bin
 test: generate-mocks lint bin/ginkgo bin/kubectl bin/kube-apiserver bin/etcd ## Run tests. At the moment this is only unit tests.
 	@./hack/testing_ginkgo_recover_statements.sh --add # Add ginkgo.GinkgoRecover() statements to controllers.
 	@# The following is a slightly funky way to make sure the ginkgo statements are removed regardless the test results.
-	@ginkgo -v ./api/... ./controllers/... ./pkg/... -coverprofile cover.out; EXIT_STATUS=$$?;\
-		./hack/testing_ginkgo_recover_statements.sh --remove; exit $$EXIT_STATUS
+	@cd ./test/unit && ginkgo -v ./... -coverprofile cover.out; EXIT_STATUS=$$?;\
+		cd ../../ && ./hack/testing_ginkgo_recover_statements.sh --remove; exit $$EXIT_STATUS
 
 .PHONY: generate-mocks
 generate-mocks: bin/mockgen generate-deepcopy pkg/mocks/mock_client.go $(shell find ./pkg/mocks -type f -name "mock*.go") ## Generate mocks needed for testing. Primarily mocks of the cloud package.

test/unit/cloud/affinity_groups_test.go

@@ -0,0 +1,99 @@
+/*
+Copyright 2022 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package cloud_test
+
+import (
+	"errors"
+
+	"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"
+)
+
+var _ = Describe("AffinityGroup Unit Tests", func() {
+	var ( // Declare shared vars.
+		mockCtrl   *gomock.Controller
+		mockClient *cloudstack.CloudStackClient
+		ags        *cloudstack.MockAffinityGroupServiceIface
+		client     cloud.Client
+	)
+
+	BeforeEach(func() {
+		// Setup new mock services.
+		mockCtrl = gomock.NewController(GinkgoT())
+		mockClient = cloudstack.NewMockClient(mockCtrl)
+		ags = mockClient.AffinityGroup.(*cloudstack.MockAffinityGroupServiceIface)
+		client = cloud.NewClientFromCSAPIClient(mockClient)
+		dummies.SetDummyVars()
+	})
+
+	AfterEach(func() {
+		mockCtrl.Finish()
+	})
+
+	It("fetches an affinity group", func() {
+		dummies.AffinityGroup.ID = "" // Force name fetching.
+		ags.EXPECT().GetAffinityGroupByName(dummies.AffinityGroup.Name).Return(&cloudstack.AffinityGroup{}, 1, nil)
+
+		Ω(client.GetOrCreateAffinityGroup(dummies.AffinityGroup)).Should(Succeed())
+	})
+	It("creates an affinity group", func() {
+		dummies.SetDummyDomainAndAccount()
+		dummies.SetDummyDomainID()
+		ags.EXPECT().GetAffinityGroupByID(dummies.AffinityGroup.ID).Return(nil, -1, errors.New("FakeError"))
+		ags.EXPECT().NewCreateAffinityGroupParams(dummies.AffinityGroup.Name, dummies.AffinityGroup.Type).
+			Return(&cloudstack.CreateAffinityGroupParams{})
+		ags.EXPECT().CreateAffinityGroup(ParamMatch(And(NameEquals(dummies.AffinityGroup.Name)))).
+			Return(&cloudstack.CreateAffinityGroupResponse{}, nil)
+
+		Ω(client.GetOrCreateAffinityGroup(dummies.AffinityGroup)).Should(Succeed())
+	})
+
+	Context("AffinityGroup Integ Tests", func() {
+		client, connectionErr := cloud.NewClient("../../cloud-config")
+
+		BeforeEach(func() {
+			if connectionErr != nil { // Only do these tests if an actual ACS instance is available via cloud-config.
+				Skip("Could not connect to ACS instance.")
+			}
+			dummies.AffinityGroup.ID = "" // Force name fetching.
+		})
+		AfterEach(func() {
+			mockCtrl.Finish()
+		})
+
+		It("Creates an affinity group.", func() {
+			Ω(client.GetOrCreateAffinityGroup(dummies.AffinityGroup)).Should(Succeed())
+		})
+		It("Associates an affinity group.", func() {
+			if err := client.GetOrCreateVMInstance(
+				dummies.CSMachine1, dummies.CAPIMachine, dummies.CSCluster, dummies.CSZone1, dummies.CSAffinityGroup, "",
+			); err != nil {
+				Skip("Could not create VM." + err.Error())
+			}
+			Ω(client.GetOrCreateAffinityGroup(dummies.AffinityGroup)).Should(Succeed())
+			Ω(client.AssociateAffinityGroup(dummies.CSMachine1, *dummies.AffinityGroup)).Should(Succeed())
+		})
+		It("Deletes an affinity group.", func() {
+			Ω(client.DeleteAffinityGroup(dummies.AffinityGroup)).Should(Succeed())
+			Ω(client.FetchAffinityGroup(dummies.AffinityGroup)).ShouldNot(Succeed())
+		})
+	})
+})

test/unit/cloud/client_test.go

@@ -0,0 +1,56 @@
+/*
+Copyright 2022 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package cloud_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"gopkg.in/ini.v1"
+)
+
+// Example cloud-config ini structure.
+type Global struct {
+	APIURL    string `ini:"api-url"`
+	VerifySSL bool   `ini:"verify-ssl"`
+}
+
+var _ = Describe("Instance", func() {
+
+	var ()
+
+	BeforeEach(func() {
+		// This test fixture is useful for development, but the actual method of parsing is confinded to the client's
+		// new client method. The parsing used here is more of a schema, and we don't need to test another library's
+		// abilities to parse said schema.
+		Skip("Dev test suite.")
+	})
+
+	AfterEach(func() {
+	})
+
+	Context("When fetching an INI config.", func() {
+		It("Handles the positive case.", func() {
+			cfg := &Global{}
+			rawCfg, err := ini.Load("../../cloud-config")
+			Ω(rawCfg.Section("Global")).ShouldNot(BeNil())
+			Ω(err).ShouldNot(HaveOccurred())
+			Ω(rawCfg.Section("Global").MapTo(cfg)).Should(Succeed())
+			Ω(cfg.VerifySSL).Should(BeFalse())
+			Ω(cfg.APIURL).ShouldNot(BeEmpty())
+		})
+	})
+})

test/unit/cloud/cloud_suite_test.go

@@ -0,0 +1,29 @@
+/*
+Copyright 2022 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package cloud_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestCloud(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Cloud Suite")
+}

test/unit/cloud/helpers_test.go

@@ -0,0 +1,129 @@
+/*
+Copyright 2022 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package cloud_test
+
+import (
+	"bytes"
+	"compress/gzip"
+	"encoding/base64"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path"
+	"reflect"
+
+	"github.com/aws/cluster-api-provider-cloudstack/pkg/cloud"
+	"github.com/golang/mock/gomock"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/onsi/gomega/types"
+)
+
+const (
+	FixturePath = "test/fixtures/cloud-config-files"
+)
+
+var _ = Describe("Helpers", func() {
+
+	Context("For a configuration with the 'Global' section missing", func() {
+		It("Gets API configuration", func() {
+			filepath := getConfigPath("cloud-config-no-global")
+
+			client, err := cloud.NewClient(filepath)
+
+			Ω(client).Should(BeNil())
+			Ω(err.Error()).Should(ContainSubstring("section Global not found"))
+		})
+	})
+
+	It("should compress and encode string", func() {
+		str := "Hello World"
+
+		compressedAndEncodedData, err := cloud.CompressAndEncodeString(str)
+
+		compressedData, _ := base64.StdEncoding.DecodeString(compressedAndEncodedData)
+		reader, _ := gzip.NewReader(bytes.NewReader(compressedData))
+		result, _ := ioutil.ReadAll(reader)
+
+		Ω(err).Should(BeNil())
+		Ω(string(result)).Should(Equal(str))
+	})
+})
+
+func getConfigPath(filename string) string {
+	dir, _ := os.Getwd()
+	return path.Join(dir, FixturePath, filename)
+}
+
+// This matcher is used to make gomega matching compatible with gomock parameter matching.
+// It's pretty awesome!
+//
+// This sort of hacks the gomock interface to inject a gomega matcher.
+//
+// Gomega matchers are far more flexible than gomock matchers, but they normally can't be used on parameters.
+
+type paramMatcher struct {
+	matcher types.GomegaMatcher
+}
+
+func ParamMatch(matcher types.GomegaMatcher) gomock.Matcher {
+	return paramMatcher{matcher}
+}
+
+func (p paramMatcher) String() string {
+	return "a gomega matcher to match, and said matcher should have panicked before this message was printed."
+}
+
+func (p paramMatcher) Matches(x interface{}) (retVal bool) {
+	return Ω(x).Should(p.matcher)
+}
+
+// This generates translating matchers.
+//
+// The CloudStack Go API uses param interfaces that can't be accessed except through builtin methods.
+//
+// This generates translation matchers:
+//
+//    Essentially it will generate a matcher that checks the value from p.Get<some field>() is Equal to an input String.
+//
+// 		DomainIDEquals = FieldMatcherGenerator("GetDomainid")
+//      p := &CreateNewSomethingParams{Domainid: "FakeDomainID"}
+//      Ω(p).DomainIDEquals("FakeDomainID")
+func FieldMatcherGenerator(fetchFunc string) func(string) types.GomegaMatcher {
+	return (func(expected string) types.GomegaMatcher {
+		return WithTransform(
+			func(x interface{}) string {
+				meth := reflect.ValueOf(x).MethodByName(fetchFunc)
+				fmt.Println(meth.Call(nil)[0])
+
+				return meth.Call(nil)[0].String()
+			}, Equal(expected))
+	})
+}
+
+var (
+	DomainIDEquals = FieldMatcherGenerator("GetDomainid")
+	AccountEquals  = FieldMatcherGenerator("GetAccount")
+	IDEquals       = FieldMatcherGenerator("GetId")
+	NameEquals     = FieldMatcherGenerator("GetName")
+)
+
+// CreateUserInSubDomain creates a sub-domain, account, and user with api-keys with a generated uuid as part of the name.
+func CreateUserInSubDomain(user *cloud.User) error {
+
+	return nil
+}