[squash post review 6] write tests with grinkgo

pkg/driver/identity_test.go

@@ -1,92 +1,90 @@
-package driver
+package driver_test
 
 import (
 	"context"
 	"strings"
-	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/scality/cosi/pkg/driver"
+
 	cosiapi "sigs.k8s.io/container-object-storage-interface-spec"
 )
 
-func TestDriverGetInfo(t *testing.T) {
-	longProvisioner := "scality-cosi-driver" + strings.Repeat("x", 1000)
+var _ = Describe("Identity Server DriverGetInfo", func() {
+	Context("with valid provisioner names", func() {
+		var (
+			request *cosiapi.DriverGetInfoRequest
+			server  cosiapi.IdentityServer
+			err     error
+		)
+
+		// Helper function to initialize the server with the given provisioner and perform DriverGetInfo
+		initAndGetInfo := func(provisionerName string) (*cosiapi.DriverGetInfoResponse, error) {
+			server, err = driver.InitIdentityServer(provisionerName)
+			Expect(err).ToNot(HaveOccurred())
+			return server.DriverGetInfo(context.Background(), request)
+		}
 
-	tests := []struct {
-		name        string
-		provisioner string
-		request     *cosiapi.DriverGetInfoRequest
-		want        *cosiapi.DriverGetInfoResponse
-		wantErr     bool
-		errCode     codes.Code
-	}{
-		{
-			name:        "Valid provisioner name",
-			provisioner: "scality-cosi-driver",
-			request:     &cosiapi.DriverGetInfoRequest{},
-			want:        &cosiapi.DriverGetInfoResponse{Name: "scality-cosi-driver"},
-			wantErr:     false,
-		},
-		{
-			name:        "Empty provisioner name",
-			provisioner: "",
-			request:     &cosiapi.DriverGetInfoRequest{},
-			want:        nil,
-			wantErr:     true,
-			errCode:     codes.InvalidArgument,
-		},
-		{
-			name:        "Empty request object",
-			provisioner: "scality-cosi-driver",
-			request:     nil, // Test for nil request to ensure function handles nil input gracefully.
-			want:        &cosiapi.DriverGetInfoResponse{Name: "scality-cosi-driver"},
-			wantErr:     false,
-		},
-		{
-			name:        "Long provisioner name",
-			provisioner: longProvisioner,
-			request:     &cosiapi.DriverGetInfoRequest{},
-			want:        &cosiapi.DriverGetInfoResponse{Name: longProvisioner},
-			wantErr:     false,
-		},
-		{
-			name:        "Provisioner name with special characters",
-			provisioner: "scality-cosi-driver-ß∂ƒ©",
-			request:     &cosiapi.DriverGetInfoRequest{},
-			want:        &cosiapi.DriverGetInfoResponse{Name: "scality-cosi-driver-ß∂ƒ©"},
-			wantErr:     false,
-		},
-	}
+		BeforeEach(func() {
+			request = &cosiapi.DriverGetInfoRequest{}
+		})
 
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			server := newIdentityServer(tt.provisioner)
+		It("should return default driver name info", func() {
+			provisionerName := "scality-cosi-driver"
+			resp, err := initAndGetInfo(provisionerName)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(resp).ToNot(BeNil())
+			Expect(resp.Name).To(Equal(provisionerName))
+		})
 
-			resp, err := server.DriverGetInfo(context.Background(), tt.request)
+		It("should return a long driver name info", func() {
+			provisionerName := "scality-cosi-driver" + strings.Repeat("x", 1000)
+			resp, err := initAndGetInfo(provisionerName)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(resp).ToNot(BeNil())
+			Expect(resp.Name).To(Equal(provisionerName))
+		})
 
-			if tt.wantErr {
-				assertErrorWithCode(t, err, tt.errCode)
-			} else {
-				assert.NoError(t, err)
-				assert.NotNil(t, resp)
-				assert.Equal(t, tt.want, resp)
-			}
+		It("should return driver name info containing special characters", func() {
+			provisionerName := "scality-cosi-driver-ß∂ƒ©"
+			resp, err := initAndGetInfo(provisionerName)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(resp).ToNot(BeNil())
+			Expect(resp.Name).To(Equal(provisionerName))
 		})
-	}
-}
+	})
 
-// Helper function to create identityServer
-func newIdentityServer(provisioner string) *identityServer {
-	return &identityServer{
-		provisioner: provisioner,
-	}
-}
+	Context("with invalid provisioner names", func() {
+		var (
+			err error
+		)
 
-// Helper function to assert error codes
-func assertErrorWithCode(t *testing.T, err error, expectedCode codes.Code) {
-	assert.Error(t, err)
-	st, _ := status.FromError(err)
-	assert.Equal(t, expectedCode, st.Code())
-}
+		It("should return an error for empty driver name", func() {
+			_, err = driver.InitIdentityServer("")
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(Equal("driver name must not be empty"))
+		})
+	})
+
+	// For now no use of request object in DriverInfo
+	// Test to ensure intentional changes in the future
+	Context("with nil request object", func() {
+		var (
+			server cosiapi.IdentityServer
+			err    error
+		)
+
+		BeforeEach(func() {
+			server, err = driver.InitIdentityServer("scality-cosi-driver")
+			Expect(err).ToNot(HaveOccurred())
+		})
+
+		It("should handle nil request gracefully", func() {
+			resp, err := server.DriverGetInfo(context.Background(), nil)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(resp).ToNot(BeNil())
+			Expect(resp.Name).To(Equal("scality-cosi-driver"))
+		})
+	})
+})