Update to csi-lib-utils@v0.15.0

Manually update to csi-lib-utils@v0.15.0

It was necessary to update to kubernetes-csi/csi-test@v5.1.0 to remove dependency on cloud.google.com/go@v0.34

vendor/github.com/kubernetes-csi/csi-test/v5/driver/driver-controller.go

@@ -0,0 +1,110 @@
+/*
+Copyright 2019 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 driver
+
+import (
+	"context"
+	"net"
+	"sync"
+
+	"google.golang.org/grpc/reflection"
+
+	csi "github.com/container-storage-interface/spec/lib/go/csi"
+	"google.golang.org/grpc"
+)
+
+// CSIDriverControllerServer is the Controller service component of the driver.
+type CSIDriverControllerServer struct {
+	Controller csi.ControllerServer
+	Identity   csi.IdentityServer
+}
+
+// CSIDriverController is the CSI Driver Controller backend.
+type CSIDriverController struct {
+	listener         net.Listener
+	server           *grpc.Server
+	controllerServer *CSIDriverControllerServer
+	wg               sync.WaitGroup
+	running          bool
+	lock             sync.Mutex
+	creds            *CSICreds
+}
+
+func NewCSIDriverController(controllerServer *CSIDriverControllerServer) *CSIDriverController {
+	return &CSIDriverController{
+		controllerServer: controllerServer,
+	}
+}
+
+func (c *CSIDriverController) goServe(started chan<- bool) {
+	goServe(c.server, &c.wg, c.listener, started)
+}
+
+func (c *CSIDriverController) Address() string {
+	return c.listener.Addr().String()
+}
+
+func (c *CSIDriverController) Start(l net.Listener) error {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	// Set listener.
+	c.listener = l
+
+	// Create a new grpc server.
+	c.server = grpc.NewServer(
+		grpc.UnaryInterceptor(c.callInterceptor),
+	)
+
+	if c.controllerServer.Controller != nil {
+		csi.RegisterControllerServer(c.server, c.controllerServer.Controller)
+	}
+	if c.controllerServer.Identity != nil {
+		csi.RegisterIdentityServer(c.server, c.controllerServer.Identity)
+	}
+
+	reflection.Register(c.server)
+
+	waitForServer := make(chan bool)
+	c.goServe(waitForServer)
+	<-waitForServer
+	c.running = true
+	return nil
+}
+
+func (c *CSIDriverController) Stop() {
+	stop(&c.lock, &c.wg, c.server, c.running)
+}
+
+func (c *CSIDriverController) Close() {
+	c.server.Stop()
+}
+
+func (c *CSIDriverController) IsRunning() bool {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	return c.running
+}
+
+func (c *CSIDriverController) SetDefaultCreds() {
+	setDefaultCreds(c.creds)
+}
+
+func (c *CSIDriverController) callInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
+	return callInterceptor(ctx, c.creds, req, info, handler)
+}

vendor/github.com/kubernetes-csi/csi-test/v5/driver/driver-node.go

@@ -0,0 +1,109 @@
+/*
+Copyright 2019 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 driver
+
+import (
+	context "context"
+	"net"
+	"sync"
+
+	csi "github.com/container-storage-interface/spec/lib/go/csi"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/reflection"
+)
+
+// CSIDriverNodeServer is the Node service component of the driver.
+type CSIDriverNodeServer struct {
+	Node     csi.NodeServer
+	Identity csi.IdentityServer
+}
+
+// CSIDriverNode is the CSI Driver Node backend.
+type CSIDriverNode struct {
+	listener   net.Listener
+	server     *grpc.Server
+	nodeServer *CSIDriverNodeServer
+	wg         sync.WaitGroup
+	running    bool
+	lock       sync.Mutex
+	creds      *CSICreds
+}
+
+func NewCSIDriverNode(nodeServer *CSIDriverNodeServer) *CSIDriverNode {
+	return &CSIDriverNode{
+		nodeServer: nodeServer,
+	}
+}
+
+func (c *CSIDriverNode) goServe(started chan<- bool) {
+	goServe(c.server, &c.wg, c.listener, started)
+}
+
+func (c *CSIDriverNode) Address() string {
+	return c.listener.Addr().String()
+}
+
+func (c *CSIDriverNode) Start(l net.Listener) error {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	// Set listener.
+	c.listener = l
+
+	// Create a new grpc server.
+	c.server = grpc.NewServer(
+		grpc.UnaryInterceptor(c.callInterceptor),
+	)
+
+	if c.nodeServer.Node != nil {
+		csi.RegisterNodeServer(c.server, c.nodeServer.Node)
+	}
+	if c.nodeServer.Identity != nil {
+		csi.RegisterIdentityServer(c.server, c.nodeServer.Identity)
+	}
+
+	reflection.Register(c.server)
+
+	waitForServer := make(chan bool)
+	c.goServe(waitForServer)
+	<-waitForServer
+	c.running = true
+	return nil
+}
+
+func (c *CSIDriverNode) Stop() {
+	stop(&c.lock, &c.wg, c.server, c.running)
+}
+
+func (c *CSIDriverNode) Close() {
+	c.server.Stop()
+}
+
+func (c *CSIDriverNode) IsRunning() bool {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	return c.running
+}
+
+func (c *CSIDriverNode) SetDefaultCreds() {
+	setDefaultCreds(c.creds)
+}
+
+func (c *CSIDriverNode) callInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
+	return callInterceptor(ctx, c.creds, req, info, handler)
+}

vendor/github.com/kubernetes-csi/csi-test/v5/driver/driver.go

@@ -0,0 +1,323 @@
+/*
+Copyright 2021 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.
+*/
+
+//go:generate mockgen -package=driver -destination=driver.mock.go github.com/container-storage-interface/spec/lib/go/csi IdentityServer,ControllerServer,NodeServer
+
+package driver
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net"
+	"sync"
+
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+	"k8s.io/klog/v2"
+
+	"github.com/container-storage-interface/spec/lib/go/csi"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/reflection"
+)
+
+var (
+	// ErrNoCredentials is the error when a secret is enabled but not passed in the request.
+	ErrNoCredentials = errors.New("secret must be provided")
+	// ErrAuthFailed is the error when the secret is incorrect.
+	ErrAuthFailed = errors.New("authentication failed")
+)
+
+// CSIDriverServers is a unified driver component with both Controller and Node
+// services.
+type CSIDriverServers struct {
+	Controller csi.ControllerServer
+	Identity   csi.IdentityServer
+	Node       csi.NodeServer
+}
+
+// This is the key name in all the CSI secret objects.
+const secretField = "secretKey"
+
+// CSICreds is a driver specific secret type. Drivers can have a key-val pair of
+// secrets. This mock driver has a single string secret with secretField as the
+// key.
+type CSICreds struct {
+	CreateVolumeSecret                         string
+	DeleteVolumeSecret                         string
+	ControllerPublishVolumeSecret              string
+	ControllerUnpublishVolumeSecret            string
+	NodeStageVolumeSecret                      string
+	NodePublishVolumeSecret                    string
+	CreateSnapshotSecret                       string
+	DeleteSnapshotSecret                       string
+	ControllerValidateVolumeCapabilitiesSecret string
+	ListSnapshotsSecret                        string
+}
+
+type CSIDriver struct {
+	listener net.Listener
+	server   *grpc.Server
+	servers  *CSIDriverServers
+	wg       sync.WaitGroup
+	running  bool
+	lock     sync.Mutex
+	creds    *CSICreds
+}
+
+func NewCSIDriver(servers *CSIDriverServers) *CSIDriver {
+	return &CSIDriver{
+		servers: servers,
+	}
+}
+
+func (c *CSIDriver) goServe(started chan<- bool) {
+	goServe(c.server, &c.wg, c.listener, started)
+}
+
+func (c *CSIDriver) Address() string {
+	return c.listener.Addr().String()
+}
+func (c *CSIDriver) Start(l net.Listener) error {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	// Set listener
+	c.listener = l
+
+	// Create a new grpc server
+	c.server = grpc.NewServer(
+		grpc.UnaryInterceptor(c.callInterceptor),
+	)
+
+	// Register Mock servers
+	if c.servers.Controller != nil {
+		csi.RegisterControllerServer(c.server, c.servers.Controller)
+	}
+	if c.servers.Identity != nil {
+		csi.RegisterIdentityServer(c.server, c.servers.Identity)
+	}
+	if c.servers.Node != nil {
+		csi.RegisterNodeServer(c.server, c.servers.Node)
+	}
+	reflection.Register(c.server)
+
+	// Start listening for requests
+	waitForServer := make(chan bool)
+	c.goServe(waitForServer)
+	<-waitForServer
+	c.running = true
+	return nil
+}
+
+func (c *CSIDriver) Stop() {
+	stop(&c.lock, &c.wg, c.server, c.running)
+}
+
+func (c *CSIDriver) Close() {
+	c.server.Stop()
+}
+
+func (c *CSIDriver) IsRunning() bool {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	return c.running
+}
+
+// SetDefaultCreds sets the default secrets for CSI creds.
+func (c *CSIDriver) SetDefaultCreds() {
+	setDefaultCreds(c.creds)
+}
+
+func (c *CSIDriver) callInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
+	return callInterceptor(ctx, c.creds, req, info, handler)
+}
+
+// goServe starts a grpc server.
+func goServe(server *grpc.Server, wg *sync.WaitGroup, listener net.Listener, started chan<- bool) {
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		started <- true
+		err := server.Serve(listener)
+		if err != nil {
+			panic(err.Error())
+		}
+	}()
+}
+
+// stop stops a grpc server.
+func stop(lock *sync.Mutex, wg *sync.WaitGroup, server *grpc.Server, running bool) {
+	lock.Lock()
+	defer lock.Unlock()
+
+	if !running {
+		return
+	}
+
+	server.Stop()
+	wg.Wait()
+}
+
+// setDefaultCreds sets the default credentials, given a CSICreds instance.
+func setDefaultCreds(creds *CSICreds) {
+	creds = &CSICreds{
+		CreateVolumeSecret:                         "secretval1",
+		DeleteVolumeSecret:                         "secretval2",
+		ControllerPublishVolumeSecret:              "secretval3",
+		ControllerUnpublishVolumeSecret:            "secretval4",
+		NodeStageVolumeSecret:                      "secretval5",
+		NodePublishVolumeSecret:                    "secretval6",
+		CreateSnapshotSecret:                       "secretval7",
+		DeleteSnapshotSecret:                       "secretval8",
+		ControllerValidateVolumeCapabilitiesSecret: "secretval9",
+		ListSnapshotsSecret:                        "secretval10",
+	}
+}
+
+func callInterceptor(ctx context.Context, creds *CSICreds, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
+	err := authInterceptor(creds, req)
+	if err != nil {
+		logGRPC(info.FullMethod, req, nil, err)
+		return nil, err
+	}
+	rsp, err := handler(ctx, req)
+	logGRPC(info.FullMethod, req, rsp, err)
+	return rsp, err
+}
+
+func authInterceptor(creds *CSICreds, req interface{}) error {
+	if creds != nil {
+		authenticated, authErr := isAuthenticated(req, creds)
+		if !authenticated {
+			if authErr == ErrNoCredentials {
+				return status.Error(codes.InvalidArgument, authErr.Error())
+			}
+			if authErr == ErrAuthFailed {
+				return status.Error(codes.Unauthenticated, authErr.Error())
+			}
+		}
+	}
+	return nil
+}
+
+func logGRPC(method string, request, reply interface{}, err error) {
+	// Log JSON with the request and response for easier parsing
+	logMessage := struct {
+		Method   string
+		Request  interface{}
+		Response interface{}
+		// Error as string, for backward compatibility.
+		// "" on no error.
+		Error string
+		// Full error dump, to be able to parse out full gRPC error code and message separately in a test.
+		FullError error
+	}{
+		Method:    method,
+		Request:   request,
+		Response:  reply,
+		FullError: err,
+	}
+
+	if err != nil {
+		logMessage.Error = err.Error()
+	}
+
+	msg, err := json.Marshal(logMessage)
+	if err != nil {
+		logMessage.Error = err.Error()
+	}
+	klog.V(3).Infof("gRPCCall: %s\n", msg)
+}
+
+func isAuthenticated(req interface{}, creds *CSICreds) (bool, error) {
+	switch r := req.(type) {
+	case *csi.CreateVolumeRequest:
+		return authenticateCreateVolume(r, creds)
+	case *csi.DeleteVolumeRequest:
+		return authenticateDeleteVolume(r, creds)
+	case *csi.ControllerPublishVolumeRequest:
+		return authenticateControllerPublishVolume(r, creds)
+	case *csi.ControllerUnpublishVolumeRequest:
+		return authenticateControllerUnpublishVolume(r, creds)
+	case *csi.NodeStageVolumeRequest:
+		return authenticateNodeStageVolume(r, creds)
+	case *csi.NodePublishVolumeRequest:
+		return authenticateNodePublishVolume(r, creds)
+	case *csi.CreateSnapshotRequest:
+		return authenticateCreateSnapshot(r, creds)
+	case *csi.DeleteSnapshotRequest:
+		return authenticateDeleteSnapshot(r, creds)
+	case *csi.ValidateVolumeCapabilitiesRequest:
+		return authenticateControllerValidateVolumeCapabilities(r, creds)
+	case *csi.ListSnapshotsRequest:
+		return authenticateListSnapshots(r, creds)
+	default:
+		return true, nil
+	}
+}
+
+func authenticateCreateVolume(req *csi.CreateVolumeRequest, creds *CSICreds) (bool, error) {
+	return credsCheck(req.GetSecrets(), creds.CreateVolumeSecret)
+}
+
+func authenticateDeleteVolume(req *csi.DeleteVolumeRequest, creds *CSICreds) (bool, error) {
+	return credsCheck(req.GetSecrets(), creds.DeleteVolumeSecret)
+}
+
+func authenticateControllerPublishVolume(req *csi.ControllerPublishVolumeRequest, creds *CSICreds) (bool, error) {
+	return credsCheck(req.GetSecrets(), creds.ControllerPublishVolumeSecret)
+}
+
+func authenticateControllerUnpublishVolume(req *csi.ControllerUnpublishVolumeRequest, creds *CSICreds) (bool, error) {
+	return credsCheck(req.GetSecrets(), creds.ControllerUnpublishVolumeSecret)
+}
+
+func authenticateNodeStageVolume(req *csi.NodeStageVolumeRequest, creds *CSICreds) (bool, error) {
+	return credsCheck(req.GetSecrets(), creds.NodeStageVolumeSecret)
+}
+
+func authenticateNodePublishVolume(req *csi.NodePublishVolumeRequest, creds *CSICreds) (bool, error) {
+	return credsCheck(req.GetSecrets(), creds.NodePublishVolumeSecret)
+}
+
+func authenticateCreateSnapshot(req *csi.CreateSnapshotRequest, creds *CSICreds) (bool, error) {
+	return credsCheck(req.GetSecrets(), creds.CreateSnapshotSecret)
+}
+
+func authenticateDeleteSnapshot(req *csi.DeleteSnapshotRequest, creds *CSICreds) (bool, error) {
+	return credsCheck(req.GetSecrets(), creds.DeleteSnapshotSecret)
+}
+
+func authenticateControllerValidateVolumeCapabilities(req *csi.ValidateVolumeCapabilitiesRequest, creds *CSICreds) (bool, error) {
+	return credsCheck(req.GetSecrets(), creds.ControllerValidateVolumeCapabilitiesSecret)
+}
+
+func authenticateListSnapshots(req *csi.ListSnapshotsRequest, creds *CSICreds) (bool, error) {
+	return credsCheck(req.GetSecrets(), creds.ListSnapshotsSecret)
+}
+
+func credsCheck(secrets map[string]string, secretVal string) (bool, error) {
+	if len(secrets) == 0 {
+		return false, ErrNoCredentials
+	}
+
+	if secrets[secretField] != secretVal {
+		return false, ErrAuthFailed
+	}
+	return true, nil
+}

vendor/github.com/kubernetes-csi/csi-test/v5/driver/driver.mock.go

@@ -0,0 +1,392 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/container-storage-interface/spec/lib/go/csi (interfaces: IdentityServer,ControllerServer,NodeServer)
+
+// Package driver is a generated GoMock package.
+package driver
+
+import (
+	context "context"
+	csi "github.com/container-storage-interface/spec/lib/go/csi"
+	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
+)
+
+// MockIdentityServer is a mock of IdentityServer interface
+type MockIdentityServer struct {
+	ctrl     *gomock.Controller
+	recorder *MockIdentityServerMockRecorder
+}
+
+// MockIdentityServerMockRecorder is the mock recorder for MockIdentityServer
+type MockIdentityServerMockRecorder struct {
+	mock *MockIdentityServer
+}
+
+// NewMockIdentityServer creates a new mock instance
+func NewMockIdentityServer(ctrl *gomock.Controller) *MockIdentityServer {
+	mock := &MockIdentityServer{ctrl: ctrl}
+	mock.recorder = &MockIdentityServerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockIdentityServer) EXPECT() *MockIdentityServerMockRecorder {
+	return m.recorder
+}
+
+// GetPluginCapabilities mocks base method
+func (m *MockIdentityServer) GetPluginCapabilities(arg0 context.Context, arg1 *csi.GetPluginCapabilitiesRequest) (*csi.GetPluginCapabilitiesResponse, error) {
+	ret := m.ctrl.Call(m, "GetPluginCapabilities", arg0, arg1)
+	ret0, _ := ret[0].(*csi.GetPluginCapabilitiesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPluginCapabilities indicates an expected call of GetPluginCapabilities
+func (mr *MockIdentityServerMockRecorder) GetPluginCapabilities(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPluginCapabilities", reflect.TypeOf((*MockIdentityServer)(nil).GetPluginCapabilities), arg0, arg1)
+}
+
+// GetPluginInfo mocks base method
+func (m *MockIdentityServer) GetPluginInfo(arg0 context.Context, arg1 *csi.GetPluginInfoRequest) (*csi.GetPluginInfoResponse, error) {
+	ret := m.ctrl.Call(m, "GetPluginInfo", arg0, arg1)
+	ret0, _ := ret[0].(*csi.GetPluginInfoResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPluginInfo indicates an expected call of GetPluginInfo
+func (mr *MockIdentityServerMockRecorder) GetPluginInfo(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPluginInfo", reflect.TypeOf((*MockIdentityServer)(nil).GetPluginInfo), arg0, arg1)
+}
+
+// Probe mocks base method
+func (m *MockIdentityServer) Probe(arg0 context.Context, arg1 *csi.ProbeRequest) (*csi.ProbeResponse, error) {
+	ret := m.ctrl.Call(m, "Probe", arg0, arg1)
+	ret0, _ := ret[0].(*csi.ProbeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Probe indicates an expected call of Probe
+func (mr *MockIdentityServerMockRecorder) Probe(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Probe", reflect.TypeOf((*MockIdentityServer)(nil).Probe), arg0, arg1)
+}
+
+// MockControllerServer is a mock of ControllerServer interface
+type MockControllerServer struct {
+	ctrl     *gomock.Controller
+	recorder *MockControllerServerMockRecorder
+}
+
+// MockControllerServerMockRecorder is the mock recorder for MockControllerServer
+type MockControllerServerMockRecorder struct {
+	mock *MockControllerServer
+}
+
+// NewMockControllerServer creates a new mock instance
+func NewMockControllerServer(ctrl *gomock.Controller) *MockControllerServer {
+	mock := &MockControllerServer{ctrl: ctrl}
+	mock.recorder = &MockControllerServerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockControllerServer) EXPECT() *MockControllerServerMockRecorder {
+	return m.recorder
+}
+
+// ControllerExpandVolume mocks base method
+func (m *MockControllerServer) ControllerExpandVolume(arg0 context.Context, arg1 *csi.ControllerExpandVolumeRequest) (*csi.ControllerExpandVolumeResponse, error) {
+	ret := m.ctrl.Call(m, "ControllerExpandVolume", arg0, arg1)
+	ret0, _ := ret[0].(*csi.ControllerExpandVolumeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ControllerExpandVolume indicates an expected call of ControllerExpandVolume
+func (mr *MockControllerServerMockRecorder) ControllerExpandVolume(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ControllerExpandVolume", reflect.TypeOf((*MockControllerServer)(nil).ControllerExpandVolume), arg0, arg1)
+}
+
+// ControllerGetCapabilities mocks base method
+func (m *MockControllerServer) ControllerGetCapabilities(arg0 context.Context, arg1 *csi.ControllerGetCapabilitiesRequest) (*csi.ControllerGetCapabilitiesResponse, error) {
+	ret := m.ctrl.Call(m, "ControllerGetCapabilities", arg0, arg1)
+	ret0, _ := ret[0].(*csi.ControllerGetCapabilitiesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ControllerGetCapabilities indicates an expected call of ControllerGetCapabilities
+func (mr *MockControllerServerMockRecorder) ControllerGetCapabilities(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ControllerGetCapabilities", reflect.TypeOf((*MockControllerServer)(nil).ControllerGetCapabilities), arg0, arg1)
+}
+
+// ControllerPublishVolume mocks base method
+func (m *MockControllerServer) ControllerPublishVolume(arg0 context.Context, arg1 *csi.ControllerPublishVolumeRequest) (*csi.ControllerPublishVolumeResponse, error) {
+	ret := m.ctrl.Call(m, "ControllerPublishVolume", arg0, arg1)
+	ret0, _ := ret[0].(*csi.ControllerPublishVolumeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ControllerPublishVolume indicates an expected call of ControllerPublishVolume
+func (mr *MockControllerServerMockRecorder) ControllerPublishVolume(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ControllerPublishVolume", reflect.TypeOf((*MockControllerServer)(nil).ControllerPublishVolume), arg0, arg1)
+}
+
+// ControllerUnpublishVolume mocks base method
+func (m *MockControllerServer) ControllerUnpublishVolume(arg0 context.Context, arg1 *csi.ControllerUnpublishVolumeRequest) (*csi.ControllerUnpublishVolumeResponse, error) {
+	ret := m.ctrl.Call(m, "ControllerUnpublishVolume", arg0, arg1)
+	ret0, _ := ret[0].(*csi.ControllerUnpublishVolumeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ControllerUnpublishVolume indicates an expected call of ControllerUnpublishVolume
+func (mr *MockControllerServerMockRecorder) ControllerUnpublishVolume(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ControllerUnpublishVolume", reflect.TypeOf((*MockControllerServer)(nil).ControllerUnpublishVolume), arg0, arg1)
+}
+
+// CreateSnapshot mocks base method
+func (m *MockControllerServer) CreateSnapshot(arg0 context.Context, arg1 *csi.CreateSnapshotRequest) (*csi.CreateSnapshotResponse, error) {
+	ret := m.ctrl.Call(m, "CreateSnapshot", arg0, arg1)
+	ret0, _ := ret[0].(*csi.CreateSnapshotResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateSnapshot indicates an expected call of CreateSnapshot
+func (mr *MockControllerServerMockRecorder) CreateSnapshot(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockControllerServer)(nil).CreateSnapshot), arg0, arg1)
+}
+
+// CreateVolume mocks base method
+func (m *MockControllerServer) CreateVolume(arg0 context.Context, arg1 *csi.CreateVolumeRequest) (*csi.CreateVolumeResponse, error) {
+	ret := m.ctrl.Call(m, "CreateVolume", arg0, arg1)
+	ret0, _ := ret[0].(*csi.CreateVolumeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateVolume indicates an expected call of CreateVolume
+func (mr *MockControllerServerMockRecorder) CreateVolume(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolume", reflect.TypeOf((*MockControllerServer)(nil).CreateVolume), arg0, arg1)
+}
+
+// DeleteSnapshot mocks base method
+func (m *MockControllerServer) DeleteSnapshot(arg0 context.Context, arg1 *csi.DeleteSnapshotRequest) (*csi.DeleteSnapshotResponse, error) {
+	ret := m.ctrl.Call(m, "DeleteSnapshot", arg0, arg1)
+	ret0, _ := ret[0].(*csi.DeleteSnapshotResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteSnapshot indicates an expected call of DeleteSnapshot
+func (mr *MockControllerServerMockRecorder) DeleteSnapshot(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshot", reflect.TypeOf((*MockControllerServer)(nil).DeleteSnapshot), arg0, arg1)
+}
+
+// DeleteVolume mocks base method
+func (m *MockControllerServer) DeleteVolume(arg0 context.Context, arg1 *csi.DeleteVolumeRequest) (*csi.DeleteVolumeResponse, error) {
+	ret := m.ctrl.Call(m, "DeleteVolume", arg0, arg1)
+	ret0, _ := ret[0].(*csi.DeleteVolumeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteVolume indicates an expected call of DeleteVolume
+func (mr *MockControllerServerMockRecorder) DeleteVolume(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolume", reflect.TypeOf((*MockControllerServer)(nil).DeleteVolume), arg0, arg1)
+}
+
+// GetCapacity mocks base method
+func (m *MockControllerServer) GetCapacity(arg0 context.Context, arg1 *csi.GetCapacityRequest) (*csi.GetCapacityResponse, error) {
+	ret := m.ctrl.Call(m, "GetCapacity", arg0, arg1)
+	ret0, _ := ret[0].(*csi.GetCapacityResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCapacity indicates an expected call of GetCapacity
+func (mr *MockControllerServerMockRecorder) GetCapacity(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacity", reflect.TypeOf((*MockControllerServer)(nil).GetCapacity), arg0, arg1)
+}
+
+// ListSnapshots mocks base method
+func (m *MockControllerServer) ListSnapshots(arg0 context.Context, arg1 *csi.ListSnapshotsRequest) (*csi.ListSnapshotsResponse, error) {
+	ret := m.ctrl.Call(m, "ListSnapshots", arg0, arg1)
+	ret0, _ := ret[0].(*csi.ListSnapshotsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListSnapshots indicates an expected call of ListSnapshots
+func (mr *MockControllerServerMockRecorder) ListSnapshots(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnapshots", reflect.TypeOf((*MockControllerServer)(nil).ListSnapshots), arg0, arg1)
+}
+
+// ListVolumes mocks base method
+func (m *MockControllerServer) ListVolumes(arg0 context.Context, arg1 *csi.ListVolumesRequest) (*csi.ListVolumesResponse, error) {
+	ret := m.ctrl.Call(m, "ListVolumes", arg0, arg1)
+	ret0, _ := ret[0].(*csi.ListVolumesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (m *MockControllerServer) ControllerGetVolume(arg0 context.Context, arg1 *csi.ControllerGetVolumeRequest) (*csi.ControllerGetVolumeResponse, error) {
+	ret := m.ctrl.Call(m, "ControllerGetVolume", arg0, arg1)
+	ret0, _ := ret[0].(*csi.ControllerGetVolumeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ControllerGetVolume indicates an expected call of ControllerGetVolume
+func (mr *MockControllerServerMockRecorder) ControllerGetVolume(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ControllerGetVolume", reflect.TypeOf((*MockControllerServer)(nil).ControllerGetVolume), arg0, arg1)
+}
+
+// ListVolumes indicates an expected call of ListVolumes
+func (mr *MockControllerServerMockRecorder) ListVolumes(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVolumes", reflect.TypeOf((*MockControllerServer)(nil).ListVolumes), arg0, arg1)
+}
+
+// ValidateVolumeCapabilities mocks base method
+func (m *MockControllerServer) ValidateVolumeCapabilities(arg0 context.Context, arg1 *csi.ValidateVolumeCapabilitiesRequest) (*csi.ValidateVolumeCapabilitiesResponse, error) {
+	ret := m.ctrl.Call(m, "ValidateVolumeCapabilities", arg0, arg1)
+	ret0, _ := ret[0].(*csi.ValidateVolumeCapabilitiesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ValidateVolumeCapabilities indicates an expected call of ValidateVolumeCapabilities
+func (mr *MockControllerServerMockRecorder) ValidateVolumeCapabilities(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateVolumeCapabilities", reflect.TypeOf((*MockControllerServer)(nil).ValidateVolumeCapabilities), arg0, arg1)
+}
+
+// MockNodeServer is a mock of NodeServer interface
+type MockNodeServer struct {
+	ctrl     *gomock.Controller
+	recorder *MockNodeServerMockRecorder
+}
+
+// MockNodeServerMockRecorder is the mock recorder for MockNodeServer
+type MockNodeServerMockRecorder struct {
+	mock *MockNodeServer
+}
+
+// NewMockNodeServer creates a new mock instance
+func NewMockNodeServer(ctrl *gomock.Controller) *MockNodeServer {
+	mock := &MockNodeServer{ctrl: ctrl}
+	mock.recorder = &MockNodeServerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockNodeServer) EXPECT() *MockNodeServerMockRecorder {
+	return m.recorder
+}
+
+// NodeExpandVolume mocks base method
+func (m *MockNodeServer) NodeExpandVolume(arg0 context.Context, arg1 *csi.NodeExpandVolumeRequest) (*csi.NodeExpandVolumeResponse, error) {
+	ret := m.ctrl.Call(m, "NodeExpandVolume", arg0, arg1)
+	ret0, _ := ret[0].(*csi.NodeExpandVolumeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// NodeExpandVolume indicates an expected call of NodeExpandVolume
+func (mr *MockNodeServerMockRecorder) NodeExpandVolume(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeExpandVolume", reflect.TypeOf((*MockNodeServer)(nil).NodeExpandVolume), arg0, arg1)
+}
+
+// NodeGetCapabilities mocks base method
+func (m *MockNodeServer) NodeGetCapabilities(arg0 context.Context, arg1 *csi.NodeGetCapabilitiesRequest) (*csi.NodeGetCapabilitiesResponse, error) {
+	ret := m.ctrl.Call(m, "NodeGetCapabilities", arg0, arg1)
+	ret0, _ := ret[0].(*csi.NodeGetCapabilitiesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// NodeGetCapabilities indicates an expected call of NodeGetCapabilities
+func (mr *MockNodeServerMockRecorder) NodeGetCapabilities(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeGetCapabilities", reflect.TypeOf((*MockNodeServer)(nil).NodeGetCapabilities), arg0, arg1)
+}
+
+// NodeGetInfo mocks base method
+func (m *MockNodeServer) NodeGetInfo(arg0 context.Context, arg1 *csi.NodeGetInfoRequest) (*csi.NodeGetInfoResponse, error) {
+	ret := m.ctrl.Call(m, "NodeGetInfo", arg0, arg1)
+	ret0, _ := ret[0].(*csi.NodeGetInfoResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// NodeGetInfo indicates an expected call of NodeGetInfo
+func (mr *MockNodeServerMockRecorder) NodeGetInfo(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeGetInfo", reflect.TypeOf((*MockNodeServer)(nil).NodeGetInfo), arg0, arg1)
+}
+
+// NodeGetVolumeStats mocks base method
+func (m *MockNodeServer) NodeGetVolumeStats(arg0 context.Context, arg1 *csi.NodeGetVolumeStatsRequest) (*csi.NodeGetVolumeStatsResponse, error) {
+	ret := m.ctrl.Call(m, "NodeGetVolumeStats", arg0, arg1)
+	ret0, _ := ret[0].(*csi.NodeGetVolumeStatsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// NodeGetVolumeStats indicates an expected call of NodeGetVolumeStats
+func (mr *MockNodeServerMockRecorder) NodeGetVolumeStats(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeGetVolumeStats", reflect.TypeOf((*MockNodeServer)(nil).NodeGetVolumeStats), arg0, arg1)
+}
+
+// NodePublishVolume mocks base method
+func (m *MockNodeServer) NodePublishVolume(arg0 context.Context, arg1 *csi.NodePublishVolumeRequest) (*csi.NodePublishVolumeResponse, error) {
+	ret := m.ctrl.Call(m, "NodePublishVolume", arg0, arg1)
+	ret0, _ := ret[0].(*csi.NodePublishVolumeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// NodePublishVolume indicates an expected call of NodePublishVolume
+func (mr *MockNodeServerMockRecorder) NodePublishVolume(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodePublishVolume", reflect.TypeOf((*MockNodeServer)(nil).NodePublishVolume), arg0, arg1)
+}
+
+// NodeStageVolume mocks base method
+func (m *MockNodeServer) NodeStageVolume(arg0 context.Context, arg1 *csi.NodeStageVolumeRequest) (*csi.NodeStageVolumeResponse, error) {
+	ret := m.ctrl.Call(m, "NodeStageVolume", arg0, arg1)
+	ret0, _ := ret[0].(*csi.NodeStageVolumeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// NodeStageVolume indicates an expected call of NodeStageVolume
+func (mr *MockNodeServerMockRecorder) NodeStageVolume(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeStageVolume", reflect.TypeOf((*MockNodeServer)(nil).NodeStageVolume), arg0, arg1)
+}
+
+// NodeUnpublishVolume mocks base method
+func (m *MockNodeServer) NodeUnpublishVolume(arg0 context.Context, arg1 *csi.NodeUnpublishVolumeRequest) (*csi.NodeUnpublishVolumeResponse, error) {
+	ret := m.ctrl.Call(m, "NodeUnpublishVolume", arg0, arg1)
+	ret0, _ := ret[0].(*csi.NodeUnpublishVolumeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// NodeUnpublishVolume indicates an expected call of NodeUnpublishVolume
+func (mr *MockNodeServerMockRecorder) NodeUnpublishVolume(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeUnpublishVolume", reflect.TypeOf((*MockNodeServer)(nil).NodeUnpublishVolume), arg0, arg1)
+}
+
+// NodeUnstageVolume mocks base method
+func (m *MockNodeServer) NodeUnstageVolume(arg0 context.Context, arg1 *csi.NodeUnstageVolumeRequest) (*csi.NodeUnstageVolumeResponse, error) {
+	ret := m.ctrl.Call(m, "NodeUnstageVolume", arg0, arg1)
+	ret0, _ := ret[0].(*csi.NodeUnstageVolumeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// NodeUnstageVolume indicates an expected call of NodeUnstageVolume
+func (mr *MockNodeServerMockRecorder) NodeUnstageVolume(arg0, arg1 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeUnstageVolume", reflect.TypeOf((*MockNodeServer)(nil).NodeUnstageVolume), arg0, arg1)
+}

vendor/github.com/kubernetes-csi/csi-test/v5/driver/mock.go

@@ -0,0 +1,89 @@
+/*
+Copyright 2021 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 driver
+
+import (
+	"net"
+
+	"github.com/kubernetes-csi/csi-test/v5/utils"
+	"google.golang.org/grpc"
+)
+
+type MockCSIDriverServers struct {
+	Controller *MockControllerServer
+	Identity   *MockIdentityServer
+	Node       *MockNodeServer
+}
+
+type MockCSIDriver struct {
+	CSIDriver
+	conn *grpc.ClientConn
+}
+
+func NewMockCSIDriver(servers *MockCSIDriverServers) *MockCSIDriver {
+	return &MockCSIDriver{
+		CSIDriver: CSIDriver{
+			servers: &CSIDriverServers{
+				Controller: servers.Controller,
+				Node:       servers.Node,
+				Identity:   servers.Identity,
+			},
+		},
+	}
+}
+
+// StartOnAddress starts a new gRPC server listening on given address.
+func (m *MockCSIDriver) StartOnAddress(network, address string) error {
+	l, err := net.Listen(network, address)
+	if err != nil {
+		return err
+	}
+
+	if err := m.CSIDriver.Start(l); err != nil {
+		l.Close()
+		return err
+	}
+
+	return nil
+}
+
+// Start starts a new gRPC server listening on a random TCP loopback port.
+func (m *MockCSIDriver) Start() error {
+	// Listen on a port assigned by the net package
+	return m.StartOnAddress("tcp", "127.0.0.1:0")
+}
+
+func (m *MockCSIDriver) Nexus() (*grpc.ClientConn, error) {
+	// Start server
+	err := m.Start()
+	if err != nil {
+		return nil, err
+	}
+
+	// Create a client connection
+	m.conn, err = utils.Connect(m.Address(), grpc.WithInsecure())
+	if err != nil {
+		return nil, err
+	}
+
+	return m.conn, nil
+}
+
+func (m *MockCSIDriver) Close() {
+	m.conn.Close()
+	m.server.Stop()
+}