controller_test.go

/*
CSI Interface for OSD
Copyright 2017 Portworx

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 csi

import (
"encoding/json"
"errors"
"fmt"
"math"
"reflect"
"strings"
"sync"
"testing"

 csi "github.com/container-storage-interface/spec/lib/go/csi"
"github.com/gogo/protobuf/proto"
"github.com/golang/mock/gomock"
"github.com/golang/protobuf/ptypes"
"github.com/golang/protobuf/ptypes/timestamp"
"github.com/libopenstorage/openstorage/api"
"github.com/libopenstorage/openstorage/api/mock"
"github.com/libopenstorage/openstorage/api/spec"
 authsecrets "github.com/libopenstorage/openstorage/pkg/auth/secrets"
 mockLoadBalancer "github.com/libopenstorage/openstorage/pkg/loadbalancer/mock"
"github.com/libopenstorage/openstorage/pkg/units"
"github.com/stretchr/testify/assert"
"golang.org/x/net/context"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"google.golang.org/protobuf/types/known/timestamppb"
)

funccontainsCap(c csi.ControllerServiceCapability_RPC_Type, resp*csi.ControllerGetCapabilitiesResponse) bool {
for_, capability:=rangeresp.GetCapabilities() {
ifrpc:=capability.GetRpc(); rpc!=nil {
ifrpc.GetType() ==c {
returntrue
 }
 }
 }
returnfalse
}

funcgetDefaultVolumeCapabilities(t*testing.T) []*csi.VolumeCapability {
return []*csi.VolumeCapability{
 {
AccessType: &csi.VolumeCapability_Mount{
Mount: &csi.VolumeCapability_MountVolume{
FsType: "ext4",
 },
 },
 },
 }
}

funcTestControllerGetCapabilities(t*testing.T) {
// Create server and client connection
s:=newTestServer(t)
defers.Stop()

// Make a call
c:=csi.NewControllerClient(s.Conn())
resp, err:=c.ControllerGetCapabilities(context.Background(), &csi.ControllerGetCapabilitiesRequest{})
assert.NoError(t, err)
assert.NotNil(t, resp)

assert.Len(t, resp.GetCapabilities(), 8)
assert.True(t, containsCap(csi.ControllerServiceCapability_RPC_GET_VOLUME, resp))
assert.True(t, containsCap(csi.ControllerServiceCapability_RPC_CLONE_VOLUME, resp))
assert.True(t, containsCap(csi.ControllerServiceCapability_RPC_CREATE_DELETE_VOLUME, resp))
assert.True(t, containsCap(csi.ControllerServiceCapability_RPC_EXPAND_VOLUME, resp))
assert.True(t, containsCap(csi.ControllerServiceCapability_RPC_CREATE_DELETE_SNAPSHOT, resp))
assert.True(t, containsCap(csi.ControllerServiceCapability_RPC_LIST_SNAPSHOTS, resp))
assert.True(t, containsCap(csi.ControllerServiceCapability_RPC_VOLUME_CONDITION, resp))
assert.True(t, containsCap(csi.ControllerServiceCapability_RPC_GET_CAPACITY, resp))

assert.False(t, containsCap(csi.ControllerServiceCapability_RPC_UNKNOWN, resp))
}

funcTestControllerGetVolume(t*testing.T) {
// Create server and client connection
s:=newTestServer(t)
defers.Stop()

size:=int64(4*1024*1024)
used:=int64(1*1024*1024)
id:="myvol123"
vol:=&api.Volume{
Id: id,
Locator: &api.VolumeLocator{
Name: id,
 },
Spec: &api.VolumeSpec{
Size: uint64(size),
 },
Usage: uint64(used),
Status: api.VolumeStatus_VOLUME_STATUS_UP,
 }
gomock.InOrder(
s.MockDriver().
EXPECT().
Inspect(gomock.Any(), []string{id}).
Return([]*api.Volume{
vol,
 }, nil).
AnyTimes(),
 )

// Make a call
c:=csi.NewControllerClient(s.Conn())

// Get Capabilities - all OK
resp, err:=c.ControllerGetVolume(
context.Background(),
&csi.ControllerGetVolumeRequest{VolumeId: id})
assert.NoError(t, err)
assert.Equal(t, false, resp.Status.VolumeCondition.Abnormal)
assert.Equal(t, "Volume status is up", resp.Status.VolumeCondition.Message)

// Get Capabilities - down
vol.Status=api.VolumeStatus_VOLUME_STATUS_DOWN
resp, err=c.ControllerGetVolume(
context.Background(),
&csi.ControllerGetVolumeRequest{VolumeId: id})
assert.NoError(t, err)
assert.Equal(t, true, resp.Status.VolumeCondition.Abnormal)
assert.Equal(t, "Volume status is down", resp.Status.VolumeCondition.Message)

// Get Capabilities - degraded
vol.Status=api.VolumeStatus_VOLUME_STATUS_DEGRADED
resp, err=c.ControllerGetVolume(
context.Background(),
&csi.ControllerGetVolumeRequest{VolumeId: id})
assert.NoError(t, err)
assert.Equal(t, true, resp.Status.VolumeCondition.Abnormal)
assert.Equal(t, "Volume status is degraded", resp.Status.VolumeCondition.Message)

// Get Capabilities - none
vol.Status=api.VolumeStatus_VOLUME_STATUS_NONE
resp, err=c.ControllerGetVolume(
context.Background(),
&csi.ControllerGetVolumeRequest{VolumeId: id})
assert.NoError(t, err)
assert.Equal(t, true, resp.Status.VolumeCondition.Abnormal)
assert.Equal(t, "Volume status is unknown", resp.Status.VolumeCondition.Message)

// Get Capabilities - not present
vol.Status=api.VolumeStatus_VOLUME_STATUS_NOT_PRESENT
resp, err=c.ControllerGetVolume(
context.Background(),
&csi.ControllerGetVolumeRequest{VolumeId: id})
assert.NoError(t, err)
assert.Equal(t, true, resp.Status.VolumeCondition.Abnormal)
assert.Equal(t, "Volume status is not present", resp.Status.VolumeCondition.Message)
}

funcTestControllerPublishVolume(t*testing.T) {
// Create server and client connection
s:=newTestServer(t)
defers.Stop()

// Make a call
c:=csi.NewControllerClient(s.Conn())
_, err:=c.ControllerPublishVolume(context.Background(), &csi.ControllerPublishVolumeRequest{})
assert.NotNil(t, err)

serverError, ok:=status.FromError(err)
assert.True(t, ok)

assert.Equal(t, serverError.Code(), codes.Unimplemented)
assert.Contains(t, serverError.Message(), "not supported")
}

funcTestControllerUnPublishVolume(t*testing.T) {
// Create server and client connection
s:=newTestServer(t)
defers.Stop()

// Make a call
c:=csi.NewControllerClient(s.Conn())
_, err:=c.ControllerUnpublishVolume(context.Background(), &csi.ControllerUnpublishVolumeRequest{})
assert.NotNil(t, err)

serverError, ok:=status.FromError(err)
assert.True(t, ok)

assert.Equal(t, serverError.Code(), codes.Unimplemented)
assert.Contains(t, serverError.Message(), "not supported")
}

funcTestControllerValidateVolumeCapabilitiesBadArguments(t*testing.T) {
// Create server and client connection
s:=newTestServer(t)
defers.Stop()

req:=&csi.ValidateVolumeCapabilitiesRequest{}

// Miss capabilities and id
c:=csi.NewControllerClient(s.Conn())
_, err:=c.ValidateVolumeCapabilities(context.Background(), req)
assert.NotNil(t, err)

serverError, ok:=status.FromError(err)
assert.True(t, ok)

assert.Equal(t, serverError.Code(), codes.InvalidArgument)
assert.Contains(t, serverError.Message(), "capabilities")

// Miss id and capabilities len is 0
req.VolumeCapabilities= []*csi.VolumeCapability{}
_, err=c.ValidateVolumeCapabilities(context.Background(), req)
assert.NotNil(t, err)

serverError, ok=status.FromError(err)
assert.True(t, ok)

assert.Equal(t, serverError.Code(), codes.InvalidArgument)
assert.Contains(t, serverError.Message(), "capabilities")

// Miss id
req.VolumeCapabilities= []*csi.VolumeCapability{
 {},
 }
_, err=c.ValidateVolumeCapabilities(context.Background(), req)
assert.NotNil(t, err)

serverError, ok=status.FromError(err)
assert.True(t, ok)

assert.Equal(t, serverError.Code(), codes.InvalidArgument)
assert.Contains(t, serverError.Message(), "volume_id")
}

funcTestControllerValidateVolumeInvalidId(t*testing.T) {

// Create server and client connection
s:=newTestServer(t)
defers.Stop()

// Setup mock
id:="testvolumeid"
gomock.InOrder(
// First time called it will say it is not there
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{}, nil),

// Second time called it will not return an error,
// but return an empty list
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{}, nil),

// Third time it is called, it will return
// a good list with a volume with an id that does
// not match (even if this probably never could happen)
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: "bad volume id",
 },
 }, nil),
 )

req:=&csi.ValidateVolumeCapabilitiesRequest{
VolumeCapabilities: []*csi.VolumeCapability{
 {},
 },
VolumeId: id,
Secrets: map[string]string{authsecrets.SecretTokenKey: systemUserToken},
 }

// Missing everything
c:=csi.NewControllerClient(s.Conn())
_, err:=c.ValidateVolumeCapabilities(context.Background(), req)
assert.NotNil(t, err)

serverError, ok:=status.FromError(err)
assert.True(t, ok)

assert.Equal(t, serverError.Code(), codes.NotFound)
assert.Contains(t, serverError.Message(), "ID not found")

// Send again, same result
_, err=c.ValidateVolumeCapabilities(context.Background(), req)
assert.NotNil(t, err)

serverError, ok=status.FromError(err)
assert.True(t, ok)

assert.Equal(t, serverError.Code(), codes.NotFound)
assert.Contains(t, serverError.Message(), "ID not found")

// Now it should be an internal id error
_, err=c.ValidateVolumeCapabilities(context.Background(), req)
assert.NotNil(t, err)

serverError, ok=status.FromError(err)
assert.True(t, ok)

assert.Equal(t, serverError.Code(), codes.Internal)
assert.Contains(t, serverError.Message(), "Driver volume id")

serverError, ok=status.FromError(err)
assert.True(t, ok)
}

funcTestControllerValidateVolumeInvalidCapabilities(t*testing.T) {
// Create server and client connection
s:=newTestServer(t)
defers.Stop()

// Setup mock
c:=csi.NewControllerClient(s.Conn())
id:="testvolumeid"
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
 },
 }, nil).
Times(1)

// Setup validate request
req:=&csi.ValidateVolumeCapabilitiesRequest{
VolumeCapabilities: []*csi.VolumeCapability{
 {},
 },
VolumeId: id,
Secrets: map[string]string{authsecrets.SecretTokenKey: systemUserToken},
 }

// Make request
_, err:=c.ValidateVolumeCapabilities(context.Background(), req)
assert.NotNil(t, err)

serverError, ok:=status.FromError(err)
assert.True(t, ok)

assert.Equal(t, serverError.Code(), codes.InvalidArgument)
assert.Contains(t, serverError.Message(), "Cannot have both")
}

funcTestControllerValidateVolumeAccessModeSNWR(t*testing.T) {
// Create server and client connection
s:=newTestServer(t)
defers.Stop()

// Setup mock
id:="testvolumeid"

// RO SH
// x x
// * x
// x *
// * *
gomock.InOrder(
// not-RO and not-SH
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: false,
Spec: &api.VolumeSpec{
Sharedv4: false,
 },
 },
 }, nil),

// RO and not-SH
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: true,
Spec: &api.VolumeSpec{
Sharedv4: false,
 },
 },
 }, nil),

// not-RO and SH
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: false,
Spec: &api.VolumeSpec{
Sharedv4: true,
 },
 },
 }, nil),

// RO and SH
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: true,
Spec: &api.VolumeSpec{
Sharedv4: true,
 },
 },
 }, nil),
 )

// Setup request
req:=&csi.ValidateVolumeCapabilitiesRequest{
VolumeCapabilities: []*csi.VolumeCapability{
 {
AccessType: &csi.VolumeCapability_Mount{
Mount: &csi.VolumeCapability_MountVolume{},
 },
AccessMode: &csi.VolumeCapability_AccessMode{
Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
 },
 },
 },
VolumeId: id,
Secrets: map[string]string{authsecrets.SecretTokenKey: systemUserToken},
 }

// Expect non-RO and non-SH
c:=csi.NewControllerClient(s.Conn())
r, err:=c.ValidateVolumeCapabilities(context.Background(), req)
assert.Nil(t, err)
assert.NotNil(t, r.GetConfirmed())

// Expect RO and non-SH
r, err=c.ValidateVolumeCapabilities(context.Background(), req)
assert.Nil(t, err)
assert.Nil(t, r.GetConfirmed())

// Expect non-RO and SH
r, err=c.ValidateVolumeCapabilities(context.Background(), req)
assert.Nil(t, err)
assert.Nil(t, r.GetConfirmed())

// Expect RO and SH
r, err=c.ValidateVolumeCapabilities(context.Background(), req)
assert.Nil(t, err)
assert.Nil(t, r.GetConfirmed())
}

funcTestControllerValidateVolumeAccessModeSNRO(t*testing.T) {
// Create server and client connection
s:=newTestServer(t)
defers.Stop()

// Setup mock
id:="testvolumeid"

// RO SH
// x x
// * x
// x *
// * *
gomock.InOrder(
// not-RO and not-SH
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: false,
Spec: &api.VolumeSpec{
Sharedv4: false,
 },
 },
 }, nil),

// RO and not-SH
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: true,
Spec: &api.VolumeSpec{
Sharedv4: false,
 },
 },
 }, nil),

// not-RO and SH
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: false,
Spec: &api.VolumeSpec{
Sharedv4: true,
 },
 },
 }, nil),

// RO and SH
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: true,
Spec: &api.VolumeSpec{
Sharedv4: true,
 },
 },
 }, nil),
 )

// Setup request
req:=&csi.ValidateVolumeCapabilitiesRequest{
VolumeCapabilities: []*csi.VolumeCapability{
 {
AccessType: &csi.VolumeCapability_Mount{
Mount: &csi.VolumeCapability_MountVolume{},
 },
AccessMode: &csi.VolumeCapability_AccessMode{
Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_READER_ONLY,
 },
 },
 },
VolumeId: id,
Secrets: map[string]string{authsecrets.SecretTokenKey: systemUserToken},
 }

// Expect non-RO and non-SH
c:=csi.NewControllerClient(s.Conn())
r, err:=c.ValidateVolumeCapabilities(context.Background(), req)
assert.Nil(t, err)
assert.Nil(t, r.GetConfirmed())

// Expect RO and non-SH
r, err=c.ValidateVolumeCapabilities(context.Background(), req)
assert.Nil(t, err)
assert.NotNil(t, r.GetConfirmed())

// Expect non-RO and SH
r, err=c.ValidateVolumeCapabilities(context.Background(), req)
assert.Nil(t, err)
assert.Nil(t, r.GetConfirmed())

// Expect RO and SH
r, err=c.ValidateVolumeCapabilities(context.Background(), req)
assert.Nil(t, err)
assert.Nil(t, r.GetConfirmed())
}

funcTestControllerValidateVolumeAccessModeMNRO(t*testing.T) {
// Create server and client connection
s:=newTestServer(t)
defers.Stop()

// Setup mock
id:="testvolumeid"

// RO SH
// x x
// * x
// x *
// * *
gomock.InOrder(
// not-RO and not-SH
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: false,
Spec: &api.VolumeSpec{
Sharedv4: false,
 },
 },
 }, nil),

// RO and not-SH
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: true,
Spec: &api.VolumeSpec{
Sharedv4: false,
 },
 },
 }, nil),

// not-RO and SH
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: false,
Spec: &api.VolumeSpec{
Sharedv4: true,
 },
 },
 }, nil),

// RO and SH
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: true,
Spec: &api.VolumeSpec{
Sharedv4: true,
 },
 },
 }, nil),
 )

// Setup request
req:=&csi.ValidateVolumeCapabilitiesRequest{
VolumeCapabilities: []*csi.VolumeCapability{
 {
AccessType: &csi.VolumeCapability_Mount{
Mount: &csi.VolumeCapability_MountVolume{},
 },
AccessMode: &csi.VolumeCapability_AccessMode{
Mode: csi.VolumeCapability_AccessMode_MULTI_NODE_READER_ONLY,
 },
 },
 },
VolumeId: id,
Secrets: map[string]string{authsecrets.SecretTokenKey: systemUserToken},
 }

// Expect non-RO and non-SH
c:=csi.NewControllerClient(s.Conn())
r, err:=c.ValidateVolumeCapabilities(context.Background(), req)
assert.Nil(t, err)
assert.Nil(t, r.GetConfirmed())

// Expect RO and non-SH
r, err=c.ValidateVolumeCapabilities(context.Background(), req)
assert.Nil(t, err)
assert.Nil(t, r.GetConfirmed())

// Expect non-RO and SH
r, err=c.ValidateVolumeCapabilities(context.Background(), req)
assert.Nil(t, err)
assert.Nil(t, r.GetConfirmed())

// Expect RO and SH
r, err=c.ValidateVolumeCapabilities(context.Background(), req)
assert.Nil(t, err)
assert.NotNil(t, r.GetConfirmed())
}

funcTestControllerValidateVolumeAccessModeMNWR(t*testing.T) {
// Create server and client connection
s:=newTestServer(t)
defers.Stop()

// Setup mock
id:="testvolumeid"

// RO SH
// x x
// * x
// x *
// * *
gomock.InOrder(
// not-RO and not-SH
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: false,
Spec: &api.VolumeSpec{
Sharedv4: false,
 },
 },
 }, nil),

// RO and not-SH
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: true,
Spec: &api.VolumeSpec{
Sharedv4: false,
 },
 },
 }, nil),

// not-RO and SH
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: false,
Spec: &api.VolumeSpec{
Sharedv4: true,
 },
 },
 }, nil),

// RO and SH
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: true,
Spec: &api.VolumeSpec{
Sharedv4: true,
 },
 },
 }, nil),
 )

// Setup request
req:=&csi.ValidateVolumeCapabilitiesRequest{
VolumeCapabilities: []*csi.VolumeCapability{
 {
AccessType: &csi.VolumeCapability_Mount{
Mount: &csi.VolumeCapability_MountVolume{},
 },
AccessMode: &csi.VolumeCapability_AccessMode{
Mode: csi.VolumeCapability_AccessMode_MULTI_NODE_MULTI_WRITER,
 },
 },
 },
VolumeId: id,
Secrets: map[string]string{authsecrets.SecretTokenKey: systemUserToken},
 }

// Expect non-RO and non-SH
c:=csi.NewControllerClient(s.Conn())
r, err:=c.ValidateVolumeCapabilities(context.Background(), req)
assert.Nil(t, err)
assert.Nil(t, r.GetConfirmed())

// Expect RO and non-SH
r, err=c.ValidateVolumeCapabilities(context.Background(), req)
assert.Nil(t, err)
assert.Nil(t, r.GetConfirmed())

// Expect non-RO and SH
r, err=c.ValidateVolumeCapabilities(context.Background(), req)
assert.Nil(t, err)
assert.NotNil(t, r.GetConfirmed())

// Expect RO and SH
r, err=c.ValidateVolumeCapabilities(context.Background(), req)
assert.Nil(t, err)
assert.Nil(t, r.GetConfirmed())
}

funcTestControllerValidateVolumeAccessModeUnknown(t*testing.T) {
// Create server and client connection
s:=newTestServer(t)
defers.Stop()

// Setup mock
id:="testvolumeid"
s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{
VolumeIds: []string{id},
 }, nil).
Return([]*api.Volume{
 {
Id: id,
Readonly: false,
Spec: &api.VolumeSpec{
Sharedv4: false,
 },
 },
 }, nil).
Times(1)

// Setup request
req:=&csi.ValidateVolumeCapabilitiesRequest{
VolumeCapabilities: []*csi.VolumeCapability{
 {
AccessType: &csi.VolumeCapability_Mount{
Mount: &csi.VolumeCapability_MountVolume{},
 },
AccessMode: &csi.VolumeCapability_AccessMode{
Mode: csi.VolumeCapability_AccessMode_UNKNOWN,
 },
 },
 },
VolumeId: id,
Secrets: map[string]string{authsecrets.SecretTokenKey: systemUserToken},
 }

// Expect non-RO and non-SH
c:=csi.NewControllerClient(s.Conn())
_, err:=c.ValidateVolumeCapabilities(context.Background(), req)
assert.NotNil(t, err)
}

funcTestControllerCreateVolumeInvalidArguments(t*testing.T) {
// Create server and client connection
s:=newTestServer(t)
defers.Stop()
c:=csi.NewControllerClient(s.Conn())

// Setup request
req:=&csi.CreateVolumeRequest{}

// No version
_, err:=c.CreateVolume(context.Background(), req)
assert.NotNil(t, err)
serverError, ok:=status.FromError(err)
assert.True(t, ok)
assert.Equal(t, serverError.Code(), codes.InvalidArgument)
assert.Contains(t, serverError.Message(), "Name")

// No volume capabilities
name:="myname"
req.Name=name
_, err=c.CreateVolume(context.Background(), req)
assert.NotNil(t, err)
serverError, ok=status.FromError(err)
assert.True(t, ok)
assert.Equal(t, serverError.Code(), codes.InvalidArgument)
assert.Contains(t, serverError.Message(), "Volume capabilities")

// Zero volume capabilities
req.VolumeCapabilities= []*csi.VolumeCapability{}
_, err=c.CreateVolume(context.Background(), req)
assert.NotNil(t, err)
serverError, ok=status.FromError(err)
assert.True(t, ok)
assert.Equal(t, serverError.Code(), codes.InvalidArgument)
assert.Contains(t, serverError.Message(), "Volume capabilities")

}

funcTestControllerCreateVolumeFoundByVolumeFromNameConflict(t*testing.T) {
// Create server and client connection
s:=newTestServer(t)
defers.Stop()
c:=csi.NewControllerClient(s.Conn())
s.mockClusterEnumerateNode(t, "node-1")
// Setup request
tests:= []struct {
namestring
req*csi.CreateVolumeRequest
ret*api.Volume
mockCalls []*gomock.Call
 }{
 {
name: "size",
req: &csi.CreateVolumeRequest{
Name: "size",
VolumeCapabilities: getDefaultVolumeCapabilities(t),
CapacityRange: &csi.CapacityRange{

// Requested size does not match volume size
RequiredBytes: 1000,
 },
Secrets: map[string]string{authsecrets.SecretTokenKey: systemUserToken},
 },
mockCalls: []*gomock.Call{
s.MockDriver().
EXPECT().
Inspect(gomock.Any(), []string{"size"}).
Return(nil, fmt.Errorf("not found")).
Times(1),

s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{Name: "size"}, nil).
Return([]*api.Volume{{
Id: "size",
Locator: &api.VolumeLocator{
Name: "size",
 },
Status: api.VolumeStatus_VOLUME_STATUS_UP,
Spec: &api.VolumeSpec{

// Size is different
Size: 10,
 },
 }}, nil).
Times(1),

s.MockDriver().
EXPECT().
Inspect(gomock.Any(), []string{"size"}).
Return(nil, fmt.Errorf("not found")).
Times(1),

s.MockDriver().
EXPECT().
Enumerate(&api.VolumeLocator{Name: "size"}, nil).
Return([]*api.Volume{{
Id: "size",
Locator: &api.VolumeLocator{
Name: "size",
 },
Status: api.VolumeStatus_VOLUME_STATUS_UP,
Spec: &api.VolumeSpec{

// Size is different
Size: 10,
 },
 }}, nil).
Times(1),
 },
 },
 }

for_, test:=rangetests {
gomock.InOrder(test.mockCalls...)