Fix NVMe namespace size lookup via full GET

Route NVMeNamespaceGetSize through NVMeNamespaceGetByName instead of a
REST query with fields=space.size only, which ONTAP can answer with
num_records=0 on the exact namespace path. Remove dead RestClient.NVMeNamespaceSize
and update unit tests/mocks.

Author: adkerr

mocks/mock_storage_drivers/mock_ontap/mock_api.go

@@ -3897,7 +3897,18 @@ func (d OntapAPIREST) NVMeGetNamespaceUUIDsForSubsystem(ctx context.Context, sub
 }
 
 func (d OntapAPIREST) NVMeNamespaceGetSize(ctx context.Context, namespacePath string) (int, error) {
-	return d.api.NVMeNamespaceSize(ctx, namespacePath)
+	ns, err := d.NVMeNamespaceGetByName(ctx, namespacePath)
+	if err != nil {
+		return 0, err
+	}
+	if ns.Size == "" {
+		return 0, errors.NotFoundError("namespace %s size not yet available", namespacePath)
+	}
+	size, err := strconv.Atoi(ns.Size)
+	if err != nil {
+		return 0, fmt.Errorf("namespace %s: invalid size %q: %w", namespacePath, ns.Size, err)
+	}
+	return size, nil
 }
 
 func (d OntapAPIREST) StorageUnitExists(ctx context.Context, suName string) (bool, error) {

mocks/mock_storage_drivers/mock_ontap/mock_ontap_rest_interface.go

@@ -384,6 +384,70 @@ func TestNVMeNamespaceGetByName(t *testing.T) {
 	assert.Error(t, err)
 }
 
+func TestNVMeNamespaceGetSize(t *testing.T) {
+	clientConfig := api.ClientConfig{
+		DebugTraceFlags: map[string]bool{"method": true},
+	}
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	mock := mockapi.NewMockRestClientInterface(ctrl)
+	oapi, err := api.NewOntapAPIRESTFromRestClientInterface(mock)
+	assert.NoError(t, err)
+
+	name := "fakeNS"
+	uuid := "fakeUUID"
+	location := &models.NvmeNamespaceInlineLocation{
+		Volume: &models.NvmeNamespaceInlineLocationInlineVolume{
+			Name: &name,
+		},
+	}
+	spaceWithSize := &models.NvmeNamespaceInlineSpace{
+		BlockSize: new(int64(4096)),
+		Size:      new(int64(99999)),
+	}
+	spaceWithoutSize := &models.NvmeNamespaceInlineSpace{
+		BlockSize: new(int64(4096)),
+	}
+	status := &models.NvmeNamespaceInlineStatus{
+		State: new("fakeState"),
+	}
+	nsWithSize := &models.NvmeNamespace{
+		Name:     &name,
+		UUID:     &uuid,
+		OsType:   new("fakeOS"),
+		Location: location,
+		Space:    spaceWithSize,
+		Status:   status,
+	}
+	nsWithoutSize := &models.NvmeNamespace{
+		Name:     &name,
+		UUID:     &uuid,
+		OsType:   new("fakeOS"),
+		Location: location,
+		Space:    spaceWithoutSize,
+		Status:   status,
+	}
+
+	mock.EXPECT().ClientConfig().Return(clientConfig).AnyTimes()
+
+	mock.EXPECT().NVMeNamespaceGetByName(ctx, name, gomock.Any()).Return(nsWithSize, nil)
+	size, err := oapi.NVMeNamespaceGetSize(ctx, name)
+	assert.NoError(t, err)
+	assert.Equal(t, 99999, size)
+
+	mock.EXPECT().NVMeNamespaceGetByName(ctx, name, gomock.Any()).Return(nil, errors.New("error while getting namespace"))
+	size, err = oapi.NVMeNamespaceGetSize(ctx, name)
+	assert.Error(t, err)
+	assert.Zero(t, size)
+
+	mock.EXPECT().NVMeNamespaceGetByName(ctx, name, gomock.Any()).Return(nsWithoutSize, nil)
+	size, err = oapi.NVMeNamespaceGetSize(ctx, name)
+	assert.Error(t, err)
+	assert.True(t, errors.IsNotFoundError(err))
+	assert.Zero(t, size)
+}
+
 func TestNVMeNamespaceList(t *testing.T) {
 	clientConfig := api.ClientConfig{
 		DebugTraceFlags: map[string]bool{"method": true},

storage_drivers/ontap/api/abstraction_rest.go

@@ -7817,20 +7817,6 @@ func (c *RestClient) NVMeGetHostsOfSubsystem(ctx context.Context, subsUUID strin
 	return nil, fmt.Errorf("get hosts of a subsystem call failed")
 }
 
-// NVMeNamespaceSize returns the size of the namespace
-func (c *RestClient) NVMeNamespaceSize(ctx context.Context, namespacePath string) (int, error) {
-	fields := []string{"space.size"}
-	namespace, err := c.NVMeNamespaceGetByName(ctx, namespacePath, fields)
-	if err != nil {
-		return 0, err
-	}
-	if namespace == nil {
-		return 0, errors.NotFoundError("could not find namespace with name %v", namespace)
-	}
-	size := namespace.Space.Size
-	return int(*size), nil
-}
-
 // ///////////////////////////////////////////////////////////////////////////
 
 // ////////////////////////////////////////////////////////////////////////////

storage_drivers/ontap/api/abstraction_rest_test.go

@@ -4104,34 +4104,6 @@ func TestOntapRestNVMeGetHostsOfSubsystem(t *testing.T) {
 	}
 }
 
-func TestOntapRestNVMeNamespaceSize(t *testing.T) {
-	tests := []struct {
-		name            string
-		mockFunction    func(w http.ResponseWriter, r *http.Request)
-		isErrorExpected bool
-	}{
-		{"PositiveTest", mockNvmeNamespaceResponse, false},
-		{"BackendReturnError", mockNvmeResourceNotFound, true},
-		{"BackendReturnNilResponse", mockNvmeNamespaceResponseNil, true},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			server := httptest.NewServer(http.HandlerFunc(test.mockFunction))
-			rs := newRestClient(server.Listener.Addr().String(), server.Client())
-			assert.NotNil(t, rs)
-
-			size, err := rs.NVMeNamespaceSize(ctx, "namespace1")
-			if !test.isErrorExpected {
-				assert.NoError(t, err, "failed to get NVMe namespace size")
-				assert.Equal(t, 1073741824, size)
-			} else {
-				assert.Error(t, err, "get the NVMe namespace size")
-			}
-			server.Close()
-		})
-	}
-}
-
 func mockSVM(w http.ResponseWriter, r *http.Request) {
 	mocksvm := models.Svm{
 		UUID:  new("1234"),