add csi-test to vendor
This commit is contained in:
wackxu
247
vendor/github.com/kubernetes-csi/csi-test/driver/driver.go
generated
vendored
Normal file
247
vendor/github.com/kubernetes-csi/csi-test/driver/driver.go
generated
vendored
Normal file
@@ -0,0 +1,247 @@
|
||||
/*
|
||||
Copyright 2017 Luis Pabón luis@portworx.com
|
||||
|
||||
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/v0 IdentityServer,ControllerServer,NodeServer
|
||||
|
||||
package driver
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"net"
|
||||
"sync"
|
||||
|
||||
"google.golang.org/grpc/codes"
|
||||
"google.golang.org/grpc/status"
|
||||
|
||||
"github.com/container-storage-interface/spec/lib/go/csi/v0"
|
||||
"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")
|
||||
)
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
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) {
|
||||
c.wg.Add(1)
|
||||
go func() {
|
||||
defer c.wg.Done()
|
||||
started <- true
|
||||
err := c.server.Serve(c.listener)
|
||||
if err != nil {
|
||||
panic(err.Error())
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
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.authInterceptor),
|
||||
)
|
||||
|
||||
// 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() {
|
||||
c.lock.Lock()
|
||||
defer c.lock.Unlock()
|
||||
|
||||
if !c.running {
|
||||
return
|
||||
}
|
||||
|
||||
c.server.Stop()
|
||||
c.wg.Wait()
|
||||
}
|
||||
|
||||
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() {
|
||||
c.creds = &CSICreds{
|
||||
CreateVolumeSecret: "secretval1",
|
||||
DeleteVolumeSecret: "secretval2",
|
||||
ControllerPublishVolumeSecret: "secretval3",
|
||||
ControllerUnpublishVolumeSecret: "secretval4",
|
||||
NodeStageVolumeSecret: "secretval5",
|
||||
NodePublishVolumeSecret: "secretval6",
|
||||
CreateSnapshotSecret: "secretval7",
|
||||
DeleteSnapshotSecret: "secretval8",
|
||||
}
|
||||
}
|
||||
|
||||
func (c *CSIDriver) authInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
|
||||
if c.creds != nil {
|
||||
authenticated, authErr := isAuthenticated(req, c.creds)
|
||||
if !authenticated {
|
||||
if authErr == ErrNoCredentials {
|
||||
return nil, status.Error(codes.InvalidArgument, authErr.Error())
|
||||
}
|
||||
if authErr == ErrAuthFailed {
|
||||
return nil, status.Error(codes.Unauthenticated, authErr.Error())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
h, err := handler(ctx, req)
|
||||
|
||||
return h, err
|
||||
}
|
||||
|
||||
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)
|
||||
default:
|
||||
return true, nil
|
||||
}
|
||||
}
|
||||
|
||||
func authenticateCreateVolume(req *csi.CreateVolumeRequest, creds *CSICreds) (bool, error) {
|
||||
return credsCheck(req.GetControllerCreateSecrets(), creds.CreateVolumeSecret)
|
||||
}
|
||||
|
||||
func authenticateDeleteVolume(req *csi.DeleteVolumeRequest, creds *CSICreds) (bool, error) {
|
||||
return credsCheck(req.GetControllerDeleteSecrets(), creds.DeleteVolumeSecret)
|
||||
}
|
||||
|
||||
func authenticateControllerPublishVolume(req *csi.ControllerPublishVolumeRequest, creds *CSICreds) (bool, error) {
|
||||
return credsCheck(req.GetControllerPublishSecrets(), creds.ControllerPublishVolumeSecret)
|
||||
}
|
||||
|
||||
func authenticateControllerUnpublishVolume(req *csi.ControllerUnpublishVolumeRequest, creds *CSICreds) (bool, error) {
|
||||
return credsCheck(req.GetControllerUnpublishSecrets(), creds.ControllerUnpublishVolumeSecret)
|
||||
}
|
||||
|
||||
func authenticateNodeStageVolume(req *csi.NodeStageVolumeRequest, creds *CSICreds) (bool, error) {
|
||||
return credsCheck(req.GetNodeStageSecrets(), creds.NodeStageVolumeSecret)
|
||||
}
|
||||
|
||||
func authenticateNodePublishVolume(req *csi.NodePublishVolumeRequest, creds *CSICreds) (bool, error) {
|
||||
return credsCheck(req.GetNodePublishSecrets(), creds.NodePublishVolumeSecret)
|
||||
}
|
||||
|
||||
func authenticateCreateSnapshot(req *csi.CreateSnapshotRequest, creds *CSICreds) (bool, error) {
|
||||
return credsCheck(req.GetCreateSnapshotSecrets(), creds.CreateSnapshotSecret)
|
||||
}
|
||||
|
||||
func authenticateDeleteSnapshot(req *csi.DeleteSnapshotRequest, creds *CSICreds) (bool, error) {
|
||||
return credsCheck(req.GetDeleteSnapshotSecrets(), creds.DeleteSnapshotSecret)
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
354
vendor/github.com/kubernetes-csi/csi-test/driver/driver.mock.go
generated
vendored
Normal file
354
vendor/github.com/kubernetes-csi/csi-test/driver/driver.mock.go
generated
vendored
Normal file
@@ -0,0 +1,354 @@
|
||||
// Code generated by MockGen. DO NOT EDIT.
|
||||
// Source: github.com/container-storage-interface/spec/lib/go/csi/v0 (interfaces: IdentityServer,ControllerServer,NodeServer)
|
||||
|
||||
// Package driver is a generated GoMock package.
|
||||
package driver
|
||||
|
||||
import (
|
||||
context "context"
|
||||
v0 "github.com/container-storage-interface/spec/lib/go/csi/v0"
|
||||
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 *v0.GetPluginCapabilitiesRequest) (*v0.GetPluginCapabilitiesResponse, error) {
|
||||
ret := m.ctrl.Call(m, "GetPluginCapabilities", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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 *v0.GetPluginInfoRequest) (*v0.GetPluginInfoResponse, error) {
|
||||
ret := m.ctrl.Call(m, "GetPluginInfo", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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 *v0.ProbeRequest) (*v0.ProbeResponse, error) {
|
||||
ret := m.ctrl.Call(m, "Probe", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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
|
||||
}
|
||||
|
||||
// ControllerGetCapabilities mocks base method
|
||||
func (m *MockControllerServer) ControllerGetCapabilities(arg0 context.Context, arg1 *v0.ControllerGetCapabilitiesRequest) (*v0.ControllerGetCapabilitiesResponse, error) {
|
||||
ret := m.ctrl.Call(m, "ControllerGetCapabilities", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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 *v0.ControllerPublishVolumeRequest) (*v0.ControllerPublishVolumeResponse, error) {
|
||||
ret := m.ctrl.Call(m, "ControllerPublishVolume", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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 *v0.ControllerUnpublishVolumeRequest) (*v0.ControllerUnpublishVolumeResponse, error) {
|
||||
ret := m.ctrl.Call(m, "ControllerUnpublishVolume", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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 *v0.CreateSnapshotRequest) (*v0.CreateSnapshotResponse, error) {
|
||||
ret := m.ctrl.Call(m, "CreateSnapshot", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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 *v0.CreateVolumeRequest) (*v0.CreateVolumeResponse, error) {
|
||||
ret := m.ctrl.Call(m, "CreateVolume", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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 *v0.DeleteSnapshotRequest) (*v0.DeleteSnapshotResponse, error) {
|
||||
ret := m.ctrl.Call(m, "DeleteSnapshot", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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 *v0.DeleteVolumeRequest) (*v0.DeleteVolumeResponse, error) {
|
||||
ret := m.ctrl.Call(m, "DeleteVolume", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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 *v0.GetCapacityRequest) (*v0.GetCapacityResponse, error) {
|
||||
ret := m.ctrl.Call(m, "GetCapacity", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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 *v0.ListSnapshotsRequest) (*v0.ListSnapshotsResponse, error) {
|
||||
ret := m.ctrl.Call(m, "ListSnapshots", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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 *v0.ListVolumesRequest) (*v0.ListVolumesResponse, error) {
|
||||
ret := m.ctrl.Call(m, "ListVolumes", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.ListVolumesResponse)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// 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 *v0.ValidateVolumeCapabilitiesRequest) (*v0.ValidateVolumeCapabilitiesResponse, error) {
|
||||
ret := m.ctrl.Call(m, "ValidateVolumeCapabilities", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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
|
||||
}
|
||||
|
||||
// NodeGetCapabilities mocks base method
|
||||
func (m *MockNodeServer) NodeGetCapabilities(arg0 context.Context, arg1 *v0.NodeGetCapabilitiesRequest) (*v0.NodeGetCapabilitiesResponse, error) {
|
||||
ret := m.ctrl.Call(m, "NodeGetCapabilities", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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)
|
||||
}
|
||||
|
||||
// NodeGetId mocks base method
|
||||
func (m *MockNodeServer) NodeGetId(arg0 context.Context, arg1 *v0.NodeGetIdRequest) (*v0.NodeGetIdResponse, error) {
|
||||
ret := m.ctrl.Call(m, "NodeGetId", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.NodeGetIdResponse)
|
||||
ret1, _ := ret[1].(error)
|
||||
return ret0, ret1
|
||||
}
|
||||
|
||||
// NodeGetId indicates an expected call of NodeGetId
|
||||
func (mr *MockNodeServerMockRecorder) NodeGetId(arg0, arg1 interface{}) *gomock.Call {
|
||||
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeGetId", reflect.TypeOf((*MockNodeServer)(nil).NodeGetId), arg0, arg1)
|
||||
}
|
||||
|
||||
// NodeGetInfo mocks base method
|
||||
func (m *MockNodeServer) NodeGetInfo(arg0 context.Context, arg1 *v0.NodeGetInfoRequest) (*v0.NodeGetInfoResponse, error) {
|
||||
ret := m.ctrl.Call(m, "NodeGetInfo", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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)
|
||||
}
|
||||
|
||||
// NodePublishVolume mocks base method
|
||||
func (m *MockNodeServer) NodePublishVolume(arg0 context.Context, arg1 *v0.NodePublishVolumeRequest) (*v0.NodePublishVolumeResponse, error) {
|
||||
ret := m.ctrl.Call(m, "NodePublishVolume", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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 *v0.NodeStageVolumeRequest) (*v0.NodeStageVolumeResponse, error) {
|
||||
ret := m.ctrl.Call(m, "NodeStageVolume", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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 *v0.NodeUnpublishVolumeRequest) (*v0.NodeUnpublishVolumeResponse, error) {
|
||||
ret := m.ctrl.Call(m, "NodeUnpublishVolume", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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 *v0.NodeUnstageVolumeRequest) (*v0.NodeUnstageVolumeResponse, error) {
|
||||
ret := m.ctrl.Call(m, "NodeUnstageVolume", arg0, arg1)
|
||||
ret0, _ := ret[0].(*v0.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)
|
||||
}
|
||||
83
vendor/github.com/kubernetes-csi/csi-test/driver/mock.go
generated
vendored
Normal file
83
vendor/github.com/kubernetes-csi/csi-test/driver/mock.go
generated
vendored
Normal file
@@ -0,0 +1,83 @@
|
||||
/*
|
||||
Copyright 2017 Luis Pabón luis@portworx.com
|
||||
|
||||
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/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,
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (m *MockCSIDriver) Start() error {
|
||||
// Listen on a port assigned by the net package
|
||||
l, err := net.Listen("tcp", "127.0.0.1:0")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if err := m.CSIDriver.Start(l); err != nil {
|
||||
l.Close()
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
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())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return m.conn, nil
|
||||
}
|
||||
|
||||
func (m *MockCSIDriver) Close() {
|
||||
m.conn.Close()
|
||||
m.server.Stop()
|
||||
}
|
||||
Reference in New Issue
Block a user