[release-v1.31] Add more low-hanging tests (#65)

* Add more low-hanging tests

* cleanup

* fix linter

---------

Co-authored-by: Robert Kaussow <[email protected]>

Author: stackit-ske

pkg/csi/util/suite_test.go

@@ -0,0 +1,13 @@
+package util
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestUtil(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Util Suite")
+}

pkg/csi/util/util_test.go

@@ -0,0 +1,33 @@
+package util
+
+import (
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("RoundUpSize", func() {
+	Context("when calculating allocation units", func() {
+		It("should return exact multiple when volume size is exact", func() {
+			// 10GB volume with 1GB allocation units
+			result := RoundUpSize(10*GIBIBYTE, 1*GIBIBYTE)
+			Expect(result).To(Equal(int64(10)))
+		})
+
+		It("should round up when volume size is not exact", func() {
+			// 1500MB volume with 1GB allocation units
+			result := RoundUpSize(1500*MEBIBYTE, 1*GIBIBYTE)
+			Expect(result).To(Equal(int64(2)))
+		})
+
+		It("should handle zero volume size", func() {
+			result := RoundUpSize(0, 1*GIBIBYTE)
+			Expect(result).To(Equal(int64(0)))
+		})
+
+		It("should handle allocation unit larger than volume", func() {
+			// 500MB volume with 1GB allocation units
+			result := RoundUpSize(500*MEBIBYTE, 1*GIBIBYTE)
+			Expect(result).To(Equal(int64(1)))
+		})
+	})
+})

pkg/labels/labels_test.go

@@ -0,0 +1,37 @@
+package labels
+
+import (
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Sanitize", func() {
+	Context("when sanitizing labels", func() {
+		It("should replace non-alphanumeric characters with hyphens", func() {
+			result := Sanitize("test-label_with.special@chars!")
+			Expect(result).To(Equal("test-label_with.special-chars"))
+		})
+
+		It("should trim hyphens, underscores, and dots from the beginning and end", func() {
+			result := Sanitize("...test-label---")
+			Expect(result).To(Equal("test-label"))
+		})
+
+		It("should truncate labels longer than 63 characters", func() {
+			longLabel := "this-is-a-very-long-label-that-should-be-truncated-to-63-characters-1234567890"
+			result := Sanitize(longLabel)
+			Expect(len(result)).To(BeNumerically("<=", 63))
+			Expect(result).To(Equal("this-is-a-very-long-label-that-should-be-truncated-to-63-charac"))
+		})
+
+		It("should handle empty string", func() {
+			result := Sanitize("")
+			Expect(result).To(Equal(""))
+		})
+
+		It("should handle string with only invalid characters", func() {
+			result := Sanitize("!@#$%^&*()")
+			Expect(result).To(Equal(""))
+		})
+	})
+})

pkg/labels/suit_test.go

@@ -0,0 +1,13 @@
+package labels
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestLabels(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Labels Suite")
+}

pkg/stackit/backups.go

@@ -26,6 +26,14 @@ const (
 )
 
 func (os *iaasClient) CreateBackup(ctx context.Context, name, volID, snapshotID string, tags map[string]string) (*iaas.Backup, error) {
+	if name == "" {
+		return nil, errors.New("backup name cannot be empty")
+	}
+
+	if volID == "" && snapshotID == "" {
+		return nil, errors.New("either volID or snapshotID must be provided")
+	}
+
 	var backupSource VolumeSourceTypes
 	var backupSourceID string
 	if volID != "" {
@@ -49,7 +57,12 @@ func (os *iaasClient) CreateBackup(ctx context.Context, name, volID, snapshotID
 	}
 	var httpResp *http.Response
 	ctxWithHTTPResp := runtime.WithCaptureHTTPResponse(ctx, &httpResp)
-	backup, err := os.iaas.CreateBackup(ctxWithHTTPResp, os.projectID, os.region).CreateBackupPayload(opts).Execute()
+	createBackupRequest := os.iaas.CreateBackup(ctxWithHTTPResp, os.projectID, os.region)
+	if createBackupRequest == nil {
+		return nil, errors.New("failed to create backup request")
+	}
+
+	backup, err := createBackupRequest.CreateBackupPayload(opts).Execute()
 	if err != nil {
 		if httpResp != nil {
 			reqID := httpResp.Header.Get(wait.XRequestIDHeader)

pkg/stackit/backups_test.go

@@ -53,8 +53,6 @@ var _ = Describe("Backup", func() {
 				mockCreateBackup(
 					mockCtrl,
 					mockAPI,
-					projectID,
-					region,
 					expectedPayload,
 				)
 
@@ -94,11 +92,172 @@ var _ = Describe("Backup", func() {
 				},
 			),
 		)
+	})
+
+	Context("CreateBackup error cases", func() {
+		const projectID = "project-id"
+
+		BeforeEach(func() {
+			config = &Config{
+				Global: GlobalOpts{
+					ProjectID: projectID,
+				},
+			}
+			openStack, err = CreateSTACKITProvider(mockAPI, config)
+			Expect(err).ToNot(HaveOccurred())
+		})
+
+		It("should return error when API fails", func() {
+			mockAPI.EXPECT().CreateBackup(gomock.Any(), projectID, region).Return(nil).Times(1)
+
+			backup, err := openStack.CreateBackup(context.Background(), "expected-name", "volume-id", "", nil)
+			Expect(err).To(HaveOccurred())
+			Expect(backup).To(BeNil())
+		})
 
+		It("should return error when both volID and snapshotID are empty", func() {
+			backup, err := openStack.CreateBackup(context.Background(), "expected-name", "", "", nil)
+			Expect(err).To(HaveOccurred())
+			Expect(backup).To(BeNil())
+		})
+
+		It("should return error when name is empty", func() {
+			backup, err := openStack.CreateBackup(context.Background(), "", "volume-id", "", nil)
+			Expect(err).To(HaveOccurred())
+			Expect(backup).To(BeNil())
+		})
+	})
+
+	Context("CreateBackup validation cases", func() {
+		const projectID = "project-id"
+
+		BeforeEach(func() {
+			config = &Config{
+				Global: GlobalOpts{
+					ProjectID: projectID,
+				},
+			}
+			openStack, err = CreateSTACKITProvider(mockAPI, config)
+			Expect(err).ToNot(HaveOccurred())
+		})
+
+		It("should return error when source type is invalid", func() {
+			// Test with an invalid source type
+			// Mock the API call to return nil, which will trigger our validation
+			mockAPI.EXPECT().CreateBackup(gomock.Any(), projectID, region).Return(nil).Times(1)
+
+			backup, err := openStack.CreateBackup(context.Background(), "expected-name", "volume-id", "", nil)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("failed to create backup request"))
+			Expect(backup).To(BeNil())
+		})
+
+		It("should handle special characters in tags", func() {
+			tags := map[string]string{
+				"special": "tag with spaces and !@#$%^&*()",
+				"normal":  "value",
+			}
+
+			expectedPayload := iaas.CreateBackupPayload{
+				Name: ptr.To("expected-name"),
+				Source: &iaas.BackupSource{
+					Type: ptr.To("volume"),
+					Id:   ptr.To("volume-id"),
+				},
+				Labels: ptr.To(map[string]any{
+					"special": "tag with spaces and !@#$%^&*()",
+					"normal":  "value",
+				}),
+			}
+
+			mockCreateBackup(mockCtrl, mockAPI, expectedPayload)
+
+			backup, err := openStack.CreateBackup(context.Background(), "expected-name", "volume-id", "", tags)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(backup).ToNot(BeNil())
+			Expect(backup.Id).ToNot(BeNil())
+			Expect(*backup.Id).To(Equal("expected backup"))
+		})
+	})
+
+	Context("CreateBackup edge cases", func() {
+		const projectID = "project-id"
+
+		BeforeEach(func() {
+			config = &Config{
+				Global: GlobalOpts{
+					ProjectID: projectID,
+				},
+			}
+			openStack, err = CreateSTACKITProvider(mockAPI, config)
+			Expect(err).ToNot(HaveOccurred())
+		})
+
+		It("should handle nil tags", func() {
+			expectedPayload := iaas.CreateBackupPayload{
+				Name: ptr.To("expected-name"),
+				Source: &iaas.BackupSource{
+					Type: ptr.To("volume"),
+					Id:   ptr.To("volume-id"),
+				},
+				Labels: nil,
+			}
+
+			mockCreateBackup(mockCtrl, mockAPI, expectedPayload)
+
+			backup, err := openStack.CreateBackup(context.Background(), "expected-name", "volume-id", "", nil)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(backup).ToNot(BeNil())
+			Expect(backup.Id).ToNot(BeNil())
+			Expect(*backup.Id).To(Equal("expected backup"))
+		})
+
+		It("should handle empty tags map", func() {
+			expectedPayload := iaas.CreateBackupPayload{
+				Name: ptr.To("expected-name"),
+				Source: &iaas.BackupSource{
+					Type: ptr.To("volume"),
+					Id:   ptr.To("volume-id"),
+				},
+				Labels: ptr.To(map[string]any{}),
+			}
+
+			mockCreateBackup(mockCtrl, mockAPI, expectedPayload)
+
+			backup, err := openStack.CreateBackup(context.Background(), "expected-name", "volume-id", "", map[string]string{})
+			Expect(err).ToNot(HaveOccurred())
+			Expect(backup).ToNot(BeNil())
+			Expect(backup.Id).ToNot(BeNil())
+			Expect(*backup.Id).To(Equal("expected backup"))
+		})
+
+		It("should handle long backup name", func() {
+			longName := "very-long-backup-name-" + string(make([]byte, 200))
+
+			expectedPayload := iaas.CreateBackupPayload{
+				Name: ptr.To(longName),
+				Source: &iaas.BackupSource{
+					Type: ptr.To("volume"),
+					Id:   ptr.To("volume-id"),
+				},
+			}
+
+			mockCreateBackup(mockCtrl, mockAPI, expectedPayload)
+
+			backup, err := openStack.CreateBackup(context.Background(), longName, "volume-id", "", nil)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(backup).ToNot(BeNil())
+			Expect(backup.Id).ToNot(BeNil())
+			Expect(*backup.Id).To(Equal("expected backup"))
+		})
 	})
 })
 
-func mockCreateBackup(mockCtrl *gomock.Controller, mockAPI *mock.MockDefaultApi, projectID, region string, expectedPayload iaas.CreateBackupPayload) {
+func mockCreateBackup(mockCtrl *gomock.Controller, mockAPI *mock.MockDefaultApi, expectedPayload iaas.CreateBackupPayload) {
+	const (
+		projectID = "project-id"
+		region    = "eu01"
+	)
 	createRequest := mock.NewMockApiCreateBackupRequest(mockCtrl)
 	createRequest.EXPECT().CreateBackupPayload(expectedPayload).Return(createRequest)
 	createRequest.EXPECT().Execute().Return(&iaas.Backup{Id: ptr.To("expected backup")}, nil)