cloudstack/VolumeService_mock.go

//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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.
//

// Code generated by MockGen. DO NOT EDIT.
// Source: ./cloudstack/VolumeService.go

// Package cloudstack is a generated GoMock package.
package cloudstack

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
)

// MockVolumeServiceIface is a mock of VolumeServiceIface interface.
type MockVolumeServiceIface struct {
	ctrl     *gomock.Controller
	recorder *MockVolumeServiceIfaceMockRecorder
}

// MockVolumeServiceIfaceMockRecorder is the mock recorder for MockVolumeServiceIface.
type MockVolumeServiceIfaceMockRecorder struct {
	mock *MockVolumeServiceIface
}

// NewMockVolumeServiceIface creates a new mock instance.
func NewMockVolumeServiceIface(ctrl *gomock.Controller) *MockVolumeServiceIface {
	mock := &MockVolumeServiceIface{ctrl: ctrl}
	mock.recorder = &MockVolumeServiceIfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVolumeServiceIface) EXPECT() *MockVolumeServiceIfaceMockRecorder {
	return m.recorder
}

// AttachVolume mocks base method.
func (m *MockVolumeServiceIface) AttachVolume(p *AttachVolumeParams) (*AttachVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachVolume", p)
	ret0, _ := ret[0].(*AttachVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AttachVolume indicates an expected call of AttachVolume.
func (mr *MockVolumeServiceIfaceMockRecorder) AttachVolume(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVolume", reflect.TypeOf((*MockVolumeServiceIface)(nil).AttachVolume), p)
}

// ChangeOfferingForVolume mocks base method.
func (m *MockVolumeServiceIface) ChangeOfferingForVolume(p *ChangeOfferingForVolumeParams) (*ChangeOfferingForVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeOfferingForVolume", p)
	ret0, _ := ret[0].(*ChangeOfferingForVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ChangeOfferingForVolume indicates an expected call of ChangeOfferingForVolume.
func (mr *MockVolumeServiceIfaceMockRecorder) ChangeOfferingForVolume(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeOfferingForVolume", reflect.TypeOf((*MockVolumeServiceIface)(nil).ChangeOfferingForVolume), p)
}

// CreateVolume mocks base method.
func (m *MockVolumeServiceIface) CreateVolume(p *CreateVolumeParams) (*CreateVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVolume", p)
	ret0, _ := ret[0].(*CreateVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVolume indicates an expected call of CreateVolume.
func (mr *MockVolumeServiceIfaceMockRecorder) CreateVolume(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolume", reflect.TypeOf((*MockVolumeServiceIface)(nil).CreateVolume), p)
}

// DeleteVolume mocks base method.
func (m *MockVolumeServiceIface) DeleteVolume(p *DeleteVolumeParams) (*DeleteVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVolume", p)
	ret0, _ := ret[0].(*DeleteVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVolume indicates an expected call of DeleteVolume.
func (mr *MockVolumeServiceIfaceMockRecorder) DeleteVolume(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolume", reflect.TypeOf((*MockVolumeServiceIface)(nil).DeleteVolume), p)
}

// DestroyVolume mocks base method.
func (m *MockVolumeServiceIface) DestroyVolume(p *DestroyVolumeParams) (*DestroyVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroyVolume", p)
	ret0, _ := ret[0].(*DestroyVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DestroyVolume indicates an expected call of DestroyVolume.
func (mr *MockVolumeServiceIfaceMockRecorder) DestroyVolume(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyVolume", reflect.TypeOf((*MockVolumeServiceIface)(nil).DestroyVolume), p)
}

// DetachVolume mocks base method.
func (m *MockVolumeServiceIface) DetachVolume(p *DetachVolumeParams) (*DetachVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachVolume", p)
	ret0, _ := ret[0].(*DetachVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DetachVolume indicates an expected call of DetachVolume.
func (mr *MockVolumeServiceIfaceMockRecorder) DetachVolume(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVolume", reflect.TypeOf((*MockVolumeServiceIface)(nil).DetachVolume), p)
}

// ExtractVolume mocks base method.
func (m *MockVolumeServiceIface) ExtractVolume(p *ExtractVolumeParams) (*ExtractVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExtractVolume", p)
	ret0, _ := ret[0].(*ExtractVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExtractVolume indicates an expected call of ExtractVolume.
func (mr *MockVolumeServiceIfaceMockRecorder) ExtractVolume(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExtractVolume", reflect.TypeOf((*MockVolumeServiceIface)(nil).ExtractVolume), p)
}

// GetPathForVolume mocks base method.
func (m *MockVolumeServiceIface) GetPathForVolume(p *GetPathForVolumeParams) (*GetPathForVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPathForVolume", p)
	ret0, _ := ret[0].(*GetPathForVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPathForVolume indicates an expected call of GetPathForVolume.
func (mr *MockVolumeServiceIfaceMockRecorder) GetPathForVolume(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPathForVolume", reflect.TypeOf((*MockVolumeServiceIface)(nil).GetPathForVolume), p)
}

// GetSolidFireVolumeSize mocks base method.
func (m *MockVolumeServiceIface) GetSolidFireVolumeSize(p *GetSolidFireVolumeSizeParams) (*GetSolidFireVolumeSizeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSolidFireVolumeSize", p)
	ret0, _ := ret[0].(*GetSolidFireVolumeSizeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSolidFireVolumeSize indicates an expected call of GetSolidFireVolumeSize.
func (mr *MockVolumeServiceIfaceMockRecorder) GetSolidFireVolumeSize(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSolidFireVolumeSize", reflect.TypeOf((*MockVolumeServiceIface)(nil).GetSolidFireVolumeSize), p)
}

// GetUploadParamsForVolume mocks base method.
func (m *MockVolumeServiceIface) GetUploadParamsForVolume(p *GetUploadParamsForVolumeParams) (*GetUploadParamsForVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUploadParamsForVolume", p)
	ret0, _ := ret[0].(*GetUploadParamsForVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUploadParamsForVolume indicates an expected call of GetUploadParamsForVolume.
func (mr *MockVolumeServiceIfaceMockRecorder) GetUploadParamsForVolume(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadParamsForVolume", reflect.TypeOf((*MockVolumeServiceIface)(nil).GetUploadParamsForVolume), p)
}

// GetVolumeByID mocks base method.
func (m *MockVolumeServiceIface) GetVolumeByID(id string, opts ...OptionFunc) (*Volume, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVolumeByID", varargs...)
	ret0, _ := ret[0].(*Volume)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetVolumeByID indicates an expected call of GetVolumeByID.
func (mr *MockVolumeServiceIfaceMockRecorder) GetVolumeByID(id interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumeByID", reflect.TypeOf((*MockVolumeServiceIface)(nil).GetVolumeByID), varargs...)
}

// GetVolumeByName mocks base method.
func (m *MockVolumeServiceIface) GetVolumeByName(name string, opts ...OptionFunc) (*Volume, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVolumeByName", varargs...)
	ret0, _ := ret[0].(*Volume)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetVolumeByName indicates an expected call of GetVolumeByName.
func (mr *MockVolumeServiceIfaceMockRecorder) GetVolumeByName(name interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumeByName", reflect.TypeOf((*MockVolumeServiceIface)(nil).GetVolumeByName), varargs...)
}

// GetVolumeID mocks base method.
func (m *MockVolumeServiceIface) GetVolumeID(name string, opts ...OptionFunc) (string, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVolumeID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetVolumeID indicates an expected call of GetVolumeID.
func (mr *MockVolumeServiceIfaceMockRecorder) GetVolumeID(name interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumeID", reflect.TypeOf((*MockVolumeServiceIface)(nil).GetVolumeID), varargs...)
}

// GetVolumeiScsiName mocks base method.
func (m *MockVolumeServiceIface) GetVolumeiScsiName(p *GetVolumeiScsiNameParams) (*GetVolumeiScsiNameResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVolumeiScsiName", p)
	ret0, _ := ret[0].(*GetVolumeiScsiNameResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVolumeiScsiName indicates an expected call of GetVolumeiScsiName.
func (mr *MockVolumeServiceIfaceMockRecorder) GetVolumeiScsiName(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumeiScsiName", reflect.TypeOf((*MockVolumeServiceIface)(nil).GetVolumeiScsiName), p)
}

// GetVolumesMetricByID mocks base method.
func (m *MockVolumeServiceIface) GetVolumesMetricByID(id string, opts ...OptionFunc) (*VolumesMetric, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVolumesMetricByID", varargs...)
	ret0, _ := ret[0].(*VolumesMetric)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetVolumesMetricByID indicates an expected call of GetVolumesMetricByID.
func (mr *MockVolumeServiceIfaceMockRecorder) GetVolumesMetricByID(id interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumesMetricByID", reflect.TypeOf((*MockVolumeServiceIface)(nil).GetVolumesMetricByID), varargs...)
}

// GetVolumesMetricByName mocks base method.
func (m *MockVolumeServiceIface) GetVolumesMetricByName(name string, opts ...OptionFunc) (*VolumesMetric, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVolumesMetricByName", varargs...)
	ret0, _ := ret[0].(*VolumesMetric)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetVolumesMetricByName indicates an expected call of GetVolumesMetricByName.
func (mr *MockVolumeServiceIfaceMockRecorder) GetVolumesMetricByName(name interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumesMetricByName", reflect.TypeOf((*MockVolumeServiceIface)(nil).GetVolumesMetricByName), varargs...)
}

// GetVolumesMetricID mocks base method.
func (m *MockVolumeServiceIface) GetVolumesMetricID(name string, opts ...OptionFunc) (string, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVolumesMetricID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetVolumesMetricID indicates an expected call of GetVolumesMetricID.
func (mr *MockVolumeServiceIfaceMockRecorder) GetVolumesMetricID(name interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumesMetricID", reflect.TypeOf((*MockVolumeServiceIface)(nil).GetVolumesMetricID), varargs...)
}

// ListVolumes mocks base method.
func (m *MockVolumeServiceIface) ListVolumes(p *ListVolumesParams) (*ListVolumesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVolumes", p)
	ret0, _ := ret[0].(*ListVolumesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListVolumes indicates an expected call of ListVolumes.
func (mr *MockVolumeServiceIfaceMockRecorder) ListVolumes(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVolumes", reflect.TypeOf((*MockVolumeServiceIface)(nil).ListVolumes), p)
}

// ListVolumesMetrics mocks base method.
func (m *MockVolumeServiceIface) ListVolumesMetrics(p *ListVolumesMetricsParams) (*ListVolumesMetricsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVolumesMetrics", p)
	ret0, _ := ret[0].(*ListVolumesMetricsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListVolumesMetrics indicates an expected call of ListVolumesMetrics.
func (mr *MockVolumeServiceIfaceMockRecorder) ListVolumesMetrics(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVolumesMetrics", reflect.TypeOf((*MockVolumeServiceIface)(nil).ListVolumesMetrics), p)
}

// MigrateVolume mocks base method.
func (m *MockVolumeServiceIface) MigrateVolume(p *MigrateVolumeParams) (*MigrateVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MigrateVolume", p)
	ret0, _ := ret[0].(*MigrateVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MigrateVolume indicates an expected call of MigrateVolume.
func (mr *MockVolumeServiceIfaceMockRecorder) MigrateVolume(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MigrateVolume", reflect.TypeOf((*MockVolumeServiceIface)(nil).MigrateVolume), p)
}

// NewAttachVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewAttachVolumeParams(id, virtualmachineid string) *AttachVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewAttachVolumeParams", id, virtualmachineid)
	ret0, _ := ret[0].(*AttachVolumeParams)
	return ret0
}

// NewAttachVolumeParams indicates an expected call of NewAttachVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewAttachVolumeParams(id, virtualmachineid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAttachVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewAttachVolumeParams), id, virtualmachineid)
}

// NewChangeOfferingForVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewChangeOfferingForVolumeParams(diskofferingid, id string) *ChangeOfferingForVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewChangeOfferingForVolumeParams", diskofferingid, id)
	ret0, _ := ret[0].(*ChangeOfferingForVolumeParams)
	return ret0
}

// NewChangeOfferingForVolumeParams indicates an expected call of NewChangeOfferingForVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewChangeOfferingForVolumeParams(diskofferingid, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewChangeOfferingForVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewChangeOfferingForVolumeParams), diskofferingid, id)
}

// NewCreateVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewCreateVolumeParams() *CreateVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateVolumeParams")
	ret0, _ := ret[0].(*CreateVolumeParams)
	return ret0
}

// NewCreateVolumeParams indicates an expected call of NewCreateVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewCreateVolumeParams() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewCreateVolumeParams))
}

// NewDeleteVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewDeleteVolumeParams(id string) *DeleteVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDeleteVolumeParams", id)
	ret0, _ := ret[0].(*DeleteVolumeParams)
	return ret0
}

// NewDeleteVolumeParams indicates an expected call of NewDeleteVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewDeleteVolumeParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewDeleteVolumeParams), id)
}

// NewDestroyVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewDestroyVolumeParams(id string) *DestroyVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDestroyVolumeParams", id)
	ret0, _ := ret[0].(*DestroyVolumeParams)
	return ret0
}

// NewDestroyVolumeParams indicates an expected call of NewDestroyVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewDestroyVolumeParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDestroyVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewDestroyVolumeParams), id)
}

// NewDetachVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewDetachVolumeParams() *DetachVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDetachVolumeParams")
	ret0, _ := ret[0].(*DetachVolumeParams)
	return ret0
}

// NewDetachVolumeParams indicates an expected call of NewDetachVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewDetachVolumeParams() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDetachVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewDetachVolumeParams))
}

// NewExtractVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewExtractVolumeParams(id, mode, zoneid string) *ExtractVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewExtractVolumeParams", id, mode, zoneid)
	ret0, _ := ret[0].(*ExtractVolumeParams)
	return ret0
}

// NewExtractVolumeParams indicates an expected call of NewExtractVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewExtractVolumeParams(id, mode, zoneid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewExtractVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewExtractVolumeParams), id, mode, zoneid)
}

// NewGetPathForVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewGetPathForVolumeParams(volumeid string) *GetPathForVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewGetPathForVolumeParams", volumeid)
	ret0, _ := ret[0].(*GetPathForVolumeParams)
	return ret0
}

// NewGetPathForVolumeParams indicates an expected call of NewGetPathForVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewGetPathForVolumeParams(volumeid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewGetPathForVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewGetPathForVolumeParams), volumeid)
}

// NewGetSolidFireVolumeSizeParams mocks base method.
func (m *MockVolumeServiceIface) NewGetSolidFireVolumeSizeParams(volumeid string) *GetSolidFireVolumeSizeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewGetSolidFireVolumeSizeParams", volumeid)
	ret0, _ := ret[0].(*GetSolidFireVolumeSizeParams)
	return ret0
}

// NewGetSolidFireVolumeSizeParams indicates an expected call of NewGetSolidFireVolumeSizeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewGetSolidFireVolumeSizeParams(volumeid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewGetSolidFireVolumeSizeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewGetSolidFireVolumeSizeParams), volumeid)
}

// NewGetUploadParamsForVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewGetUploadParamsForVolumeParams(format, name, zoneid string) *GetUploadParamsForVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewGetUploadParamsForVolumeParams", format, name, zoneid)
	ret0, _ := ret[0].(*GetUploadParamsForVolumeParams)
	return ret0
}

// NewGetUploadParamsForVolumeParams indicates an expected call of NewGetUploadParamsForVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewGetUploadParamsForVolumeParams(format, name, zoneid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewGetUploadParamsForVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewGetUploadParamsForVolumeParams), format, name, zoneid)
}

// NewGetVolumeiScsiNameParams mocks base method.
func (m *MockVolumeServiceIface) NewGetVolumeiScsiNameParams(volumeid string) *GetVolumeiScsiNameParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewGetVolumeiScsiNameParams", volumeid)
	ret0, _ := ret[0].(*GetVolumeiScsiNameParams)
	return ret0
}

// NewGetVolumeiScsiNameParams indicates an expected call of NewGetVolumeiScsiNameParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewGetVolumeiScsiNameParams(volumeid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewGetVolumeiScsiNameParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewGetVolumeiScsiNameParams), volumeid)
}

// NewListVolumesMetricsParams mocks base method.
func (m *MockVolumeServiceIface) NewListVolumesMetricsParams() *ListVolumesMetricsParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewListVolumesMetricsParams")
	ret0, _ := ret[0].(*ListVolumesMetricsParams)
	return ret0
}

// NewListVolumesMetricsParams indicates an expected call of NewListVolumesMetricsParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewListVolumesMetricsParams() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListVolumesMetricsParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewListVolumesMetricsParams))
}

// NewListVolumesParams mocks base method.
func (m *MockVolumeServiceIface) NewListVolumesParams() *ListVolumesParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewListVolumesParams")
	ret0, _ := ret[0].(*ListVolumesParams)
	return ret0
}

// NewListVolumesParams indicates an expected call of NewListVolumesParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewListVolumesParams() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListVolumesParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewListVolumesParams))
}

// NewMigrateVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewMigrateVolumeParams(storageid, volumeid string) *MigrateVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewMigrateVolumeParams", storageid, volumeid)
	ret0, _ := ret[0].(*MigrateVolumeParams)
	return ret0
}

// NewMigrateVolumeParams indicates an expected call of NewMigrateVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewMigrateVolumeParams(storageid, volumeid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewMigrateVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewMigrateVolumeParams), storageid, volumeid)
}

// NewRecoverVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewRecoverVolumeParams(id string) *RecoverVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRecoverVolumeParams", id)
	ret0, _ := ret[0].(*RecoverVolumeParams)
	return ret0
}

// NewRecoverVolumeParams indicates an expected call of NewRecoverVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewRecoverVolumeParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRecoverVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewRecoverVolumeParams), id)
}

// NewResizeVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewResizeVolumeParams(id string) *ResizeVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewResizeVolumeParams", id)
	ret0, _ := ret[0].(*ResizeVolumeParams)
	return ret0
}

// NewResizeVolumeParams indicates an expected call of NewResizeVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewResizeVolumeParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewResizeVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewResizeVolumeParams), id)
}

// NewUpdateVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewUpdateVolumeParams() *UpdateVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewUpdateVolumeParams")
	ret0, _ := ret[0].(*UpdateVolumeParams)
	return ret0
}

// NewUpdateVolumeParams indicates an expected call of NewUpdateVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewUpdateVolumeParams() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewUpdateVolumeParams))
}

// NewUploadVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewUploadVolumeParams(format, name, url, zoneid string) *UploadVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewUploadVolumeParams", format, name, url, zoneid)
	ret0, _ := ret[0].(*UploadVolumeParams)
	return ret0
}

// NewUploadVolumeParams indicates an expected call of NewUploadVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewUploadVolumeParams(format, name, url, zoneid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUploadVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewUploadVolumeParams), format, name, url, zoneid)
}

// RecoverVolume mocks base method.
func (m *MockVolumeServiceIface) RecoverVolume(p *RecoverVolumeParams) (*RecoverVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RecoverVolume", p)
	ret0, _ := ret[0].(*RecoverVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RecoverVolume indicates an expected call of RecoverVolume.
func (mr *MockVolumeServiceIfaceMockRecorder) RecoverVolume(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecoverVolume", reflect.TypeOf((*MockVolumeServiceIface)(nil).RecoverVolume), p)
}

// ResizeVolume mocks base method.
func (m *MockVolumeServiceIface) ResizeVolume(p *ResizeVolumeParams) (*ResizeVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResizeVolume", p)
	ret0, _ := ret[0].(*ResizeVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResizeVolume indicates an expected call of ResizeVolume.
func (mr *MockVolumeServiceIfaceMockRecorder) ResizeVolume(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResizeVolume", reflect.TypeOf((*MockVolumeServiceIface)(nil).ResizeVolume), p)
}

// UpdateVolume mocks base method.
func (m *MockVolumeServiceIface) UpdateVolume(p *UpdateVolumeParams) (*UpdateVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateVolume", p)
	ret0, _ := ret[0].(*UpdateVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateVolume indicates an expected call of UpdateVolume.
func (mr *MockVolumeServiceIfaceMockRecorder) UpdateVolume(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateVolume", reflect.TypeOf((*MockVolumeServiceIface)(nil).UpdateVolume), p)
}

// UploadVolume mocks base method.
func (m *MockVolumeServiceIface) UploadVolume(p *UploadVolumeParams) (*UploadVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadVolume", p)
	ret0, _ := ret[0].(*UploadVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UploadVolume indicates an expected call of UploadVolume.
func (mr *MockVolumeServiceIfaceMockRecorder) UploadVolume(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadVolume", reflect.TypeOf((*MockVolumeServiceIface)(nil).UploadVolume), p)
}