| // |
| // 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/SystemVMService.go |
| |
| // Package cloudstack is a generated GoMock package. |
| package cloudstack |
| |
| import ( |
| reflect "reflect" |
| |
| gomock "github.com/golang/mock/gomock" |
| ) |
| |
| // MockSystemVMServiceIface is a mock of SystemVMServiceIface interface. |
| type MockSystemVMServiceIface struct { |
| ctrl *gomock.Controller |
| recorder *MockSystemVMServiceIfaceMockRecorder |
| } |
| |
| // MockSystemVMServiceIfaceMockRecorder is the mock recorder for MockSystemVMServiceIface. |
| type MockSystemVMServiceIfaceMockRecorder struct { |
| mock *MockSystemVMServiceIface |
| } |
| |
| // NewMockSystemVMServiceIface creates a new mock instance. |
| func NewMockSystemVMServiceIface(ctrl *gomock.Controller) *MockSystemVMServiceIface { |
| mock := &MockSystemVMServiceIface{ctrl: ctrl} |
| mock.recorder = &MockSystemVMServiceIfaceMockRecorder{mock} |
| return mock |
| } |
| |
| // EXPECT returns an object that allows the caller to indicate expected use. |
| func (m *MockSystemVMServiceIface) EXPECT() *MockSystemVMServiceIfaceMockRecorder { |
| return m.recorder |
| } |
| |
| // ChangeServiceForSystemVm mocks base method. |
| func (m *MockSystemVMServiceIface) ChangeServiceForSystemVm(p *ChangeServiceForSystemVmParams) (*ChangeServiceForSystemVmResponse, error) { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "ChangeServiceForSystemVm", p) |
| ret0, _ := ret[0].(*ChangeServiceForSystemVmResponse) |
| ret1, _ := ret[1].(error) |
| return ret0, ret1 |
| } |
| |
| // ChangeServiceForSystemVm indicates an expected call of ChangeServiceForSystemVm. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) ChangeServiceForSystemVm(p interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeServiceForSystemVm", reflect.TypeOf((*MockSystemVMServiceIface)(nil).ChangeServiceForSystemVm), p) |
| } |
| |
| // DestroySystemVm mocks base method. |
| func (m *MockSystemVMServiceIface) DestroySystemVm(p *DestroySystemVmParams) (*DestroySystemVmResponse, error) { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "DestroySystemVm", p) |
| ret0, _ := ret[0].(*DestroySystemVmResponse) |
| ret1, _ := ret[1].(error) |
| return ret0, ret1 |
| } |
| |
| // DestroySystemVm indicates an expected call of DestroySystemVm. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) DestroySystemVm(p interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroySystemVm", reflect.TypeOf((*MockSystemVMServiceIface)(nil).DestroySystemVm), p) |
| } |
| |
| // GetSystemVmByID mocks base method. |
| func (m *MockSystemVMServiceIface) GetSystemVmByID(id string, opts ...OptionFunc) (*SystemVm, int, error) { |
| m.ctrl.T.Helper() |
| varargs := []interface{}{id} |
| for _, a := range opts { |
| varargs = append(varargs, a) |
| } |
| ret := m.ctrl.Call(m, "GetSystemVmByID", varargs...) |
| ret0, _ := ret[0].(*SystemVm) |
| ret1, _ := ret[1].(int) |
| ret2, _ := ret[2].(error) |
| return ret0, ret1, ret2 |
| } |
| |
| // GetSystemVmByID indicates an expected call of GetSystemVmByID. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) GetSystemVmByID(id interface{}, opts ...interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| varargs := append([]interface{}{id}, opts...) |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSystemVmByID", reflect.TypeOf((*MockSystemVMServiceIface)(nil).GetSystemVmByID), varargs...) |
| } |
| |
| // GetSystemVmByName mocks base method. |
| func (m *MockSystemVMServiceIface) GetSystemVmByName(name string, opts ...OptionFunc) (*SystemVm, int, error) { |
| m.ctrl.T.Helper() |
| varargs := []interface{}{name} |
| for _, a := range opts { |
| varargs = append(varargs, a) |
| } |
| ret := m.ctrl.Call(m, "GetSystemVmByName", varargs...) |
| ret0, _ := ret[0].(*SystemVm) |
| ret1, _ := ret[1].(int) |
| ret2, _ := ret[2].(error) |
| return ret0, ret1, ret2 |
| } |
| |
| // GetSystemVmByName indicates an expected call of GetSystemVmByName. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) GetSystemVmByName(name interface{}, opts ...interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| varargs := append([]interface{}{name}, opts...) |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSystemVmByName", reflect.TypeOf((*MockSystemVMServiceIface)(nil).GetSystemVmByName), varargs...) |
| } |
| |
| // GetSystemVmID mocks base method. |
| func (m *MockSystemVMServiceIface) GetSystemVmID(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, "GetSystemVmID", varargs...) |
| ret0, _ := ret[0].(string) |
| ret1, _ := ret[1].(int) |
| ret2, _ := ret[2].(error) |
| return ret0, ret1, ret2 |
| } |
| |
| // GetSystemVmID indicates an expected call of GetSystemVmID. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) GetSystemVmID(name interface{}, opts ...interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| varargs := append([]interface{}{name}, opts...) |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSystemVmID", reflect.TypeOf((*MockSystemVMServiceIface)(nil).GetSystemVmID), varargs...) |
| } |
| |
| // ListSystemVms mocks base method. |
| func (m *MockSystemVMServiceIface) ListSystemVms(p *ListSystemVmsParams) (*ListSystemVmsResponse, error) { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "ListSystemVms", p) |
| ret0, _ := ret[0].(*ListSystemVmsResponse) |
| ret1, _ := ret[1].(error) |
| return ret0, ret1 |
| } |
| |
| // ListSystemVms indicates an expected call of ListSystemVms. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) ListSystemVms(p interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSystemVms", reflect.TypeOf((*MockSystemVMServiceIface)(nil).ListSystemVms), p) |
| } |
| |
| // MigrateSystemVm mocks base method. |
| func (m *MockSystemVMServiceIface) MigrateSystemVm(p *MigrateSystemVmParams) (*MigrateSystemVmResponse, error) { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "MigrateSystemVm", p) |
| ret0, _ := ret[0].(*MigrateSystemVmResponse) |
| ret1, _ := ret[1].(error) |
| return ret0, ret1 |
| } |
| |
| // MigrateSystemVm indicates an expected call of MigrateSystemVm. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) MigrateSystemVm(p interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MigrateSystemVm", reflect.TypeOf((*MockSystemVMServiceIface)(nil).MigrateSystemVm), p) |
| } |
| |
| // NewChangeServiceForSystemVmParams mocks base method. |
| func (m *MockSystemVMServiceIface) NewChangeServiceForSystemVmParams(id, serviceofferingid string) *ChangeServiceForSystemVmParams { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "NewChangeServiceForSystemVmParams", id, serviceofferingid) |
| ret0, _ := ret[0].(*ChangeServiceForSystemVmParams) |
| return ret0 |
| } |
| |
| // NewChangeServiceForSystemVmParams indicates an expected call of NewChangeServiceForSystemVmParams. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) NewChangeServiceForSystemVmParams(id, serviceofferingid interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewChangeServiceForSystemVmParams", reflect.TypeOf((*MockSystemVMServiceIface)(nil).NewChangeServiceForSystemVmParams), id, serviceofferingid) |
| } |
| |
| // NewDestroySystemVmParams mocks base method. |
| func (m *MockSystemVMServiceIface) NewDestroySystemVmParams(id string) *DestroySystemVmParams { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "NewDestroySystemVmParams", id) |
| ret0, _ := ret[0].(*DestroySystemVmParams) |
| return ret0 |
| } |
| |
| // NewDestroySystemVmParams indicates an expected call of NewDestroySystemVmParams. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) NewDestroySystemVmParams(id interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDestroySystemVmParams", reflect.TypeOf((*MockSystemVMServiceIface)(nil).NewDestroySystemVmParams), id) |
| } |
| |
| // NewListSystemVmsParams mocks base method. |
| func (m *MockSystemVMServiceIface) NewListSystemVmsParams() *ListSystemVmsParams { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "NewListSystemVmsParams") |
| ret0, _ := ret[0].(*ListSystemVmsParams) |
| return ret0 |
| } |
| |
| // NewListSystemVmsParams indicates an expected call of NewListSystemVmsParams. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) NewListSystemVmsParams() *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListSystemVmsParams", reflect.TypeOf((*MockSystemVMServiceIface)(nil).NewListSystemVmsParams)) |
| } |
| |
| // NewMigrateSystemVmParams mocks base method. |
| func (m *MockSystemVMServiceIface) NewMigrateSystemVmParams(virtualmachineid string) *MigrateSystemVmParams { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "NewMigrateSystemVmParams", virtualmachineid) |
| ret0, _ := ret[0].(*MigrateSystemVmParams) |
| return ret0 |
| } |
| |
| // NewMigrateSystemVmParams indicates an expected call of NewMigrateSystemVmParams. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) NewMigrateSystemVmParams(virtualmachineid interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewMigrateSystemVmParams", reflect.TypeOf((*MockSystemVMServiceIface)(nil).NewMigrateSystemVmParams), virtualmachineid) |
| } |
| |
| // NewPatchSystemVmParams mocks base method. |
| func (m *MockSystemVMServiceIface) NewPatchSystemVmParams() *PatchSystemVmParams { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "NewPatchSystemVmParams") |
| ret0, _ := ret[0].(*PatchSystemVmParams) |
| return ret0 |
| } |
| |
| // NewPatchSystemVmParams indicates an expected call of NewPatchSystemVmParams. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) NewPatchSystemVmParams() *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewPatchSystemVmParams", reflect.TypeOf((*MockSystemVMServiceIface)(nil).NewPatchSystemVmParams)) |
| } |
| |
| // NewRebootSystemVmParams mocks base method. |
| func (m *MockSystemVMServiceIface) NewRebootSystemVmParams(id string) *RebootSystemVmParams { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "NewRebootSystemVmParams", id) |
| ret0, _ := ret[0].(*RebootSystemVmParams) |
| return ret0 |
| } |
| |
| // NewRebootSystemVmParams indicates an expected call of NewRebootSystemVmParams. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) NewRebootSystemVmParams(id interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRebootSystemVmParams", reflect.TypeOf((*MockSystemVMServiceIface)(nil).NewRebootSystemVmParams), id) |
| } |
| |
| // NewScaleSystemVmParams mocks base method. |
| func (m *MockSystemVMServiceIface) NewScaleSystemVmParams(id, serviceofferingid string) *ScaleSystemVmParams { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "NewScaleSystemVmParams", id, serviceofferingid) |
| ret0, _ := ret[0].(*ScaleSystemVmParams) |
| return ret0 |
| } |
| |
| // NewScaleSystemVmParams indicates an expected call of NewScaleSystemVmParams. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) NewScaleSystemVmParams(id, serviceofferingid interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewScaleSystemVmParams", reflect.TypeOf((*MockSystemVMServiceIface)(nil).NewScaleSystemVmParams), id, serviceofferingid) |
| } |
| |
| // NewStartSystemVmParams mocks base method. |
| func (m *MockSystemVMServiceIface) NewStartSystemVmParams(id string) *StartSystemVmParams { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "NewStartSystemVmParams", id) |
| ret0, _ := ret[0].(*StartSystemVmParams) |
| return ret0 |
| } |
| |
| // NewStartSystemVmParams indicates an expected call of NewStartSystemVmParams. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) NewStartSystemVmParams(id interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewStartSystemVmParams", reflect.TypeOf((*MockSystemVMServiceIface)(nil).NewStartSystemVmParams), id) |
| } |
| |
| // NewStopSystemVmParams mocks base method. |
| func (m *MockSystemVMServiceIface) NewStopSystemVmParams(id string) *StopSystemVmParams { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "NewStopSystemVmParams", id) |
| ret0, _ := ret[0].(*StopSystemVmParams) |
| return ret0 |
| } |
| |
| // NewStopSystemVmParams indicates an expected call of NewStopSystemVmParams. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) NewStopSystemVmParams(id interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewStopSystemVmParams", reflect.TypeOf((*MockSystemVMServiceIface)(nil).NewStopSystemVmParams), id) |
| } |
| |
| // PatchSystemVm mocks base method. |
| func (m *MockSystemVMServiceIface) PatchSystemVm(p *PatchSystemVmParams) (*PatchSystemVmResponse, error) { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "PatchSystemVm", p) |
| ret0, _ := ret[0].(*PatchSystemVmResponse) |
| ret1, _ := ret[1].(error) |
| return ret0, ret1 |
| } |
| |
| // PatchSystemVm indicates an expected call of PatchSystemVm. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) PatchSystemVm(p interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchSystemVm", reflect.TypeOf((*MockSystemVMServiceIface)(nil).PatchSystemVm), p) |
| } |
| |
| // RebootSystemVm mocks base method. |
| func (m *MockSystemVMServiceIface) RebootSystemVm(p *RebootSystemVmParams) (*RebootSystemVmResponse, error) { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "RebootSystemVm", p) |
| ret0, _ := ret[0].(*RebootSystemVmResponse) |
| ret1, _ := ret[1].(error) |
| return ret0, ret1 |
| } |
| |
| // RebootSystemVm indicates an expected call of RebootSystemVm. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) RebootSystemVm(p interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootSystemVm", reflect.TypeOf((*MockSystemVMServiceIface)(nil).RebootSystemVm), p) |
| } |
| |
| // ScaleSystemVm mocks base method. |
| func (m *MockSystemVMServiceIface) ScaleSystemVm(p *ScaleSystemVmParams) (*ScaleSystemVmResponse, error) { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "ScaleSystemVm", p) |
| ret0, _ := ret[0].(*ScaleSystemVmResponse) |
| ret1, _ := ret[1].(error) |
| return ret0, ret1 |
| } |
| |
| // ScaleSystemVm indicates an expected call of ScaleSystemVm. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) ScaleSystemVm(p interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScaleSystemVm", reflect.TypeOf((*MockSystemVMServiceIface)(nil).ScaleSystemVm), p) |
| } |
| |
| // StartSystemVm mocks base method. |
| func (m *MockSystemVMServiceIface) StartSystemVm(p *StartSystemVmParams) (*StartSystemVmResponse, error) { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "StartSystemVm", p) |
| ret0, _ := ret[0].(*StartSystemVmResponse) |
| ret1, _ := ret[1].(error) |
| return ret0, ret1 |
| } |
| |
| // StartSystemVm indicates an expected call of StartSystemVm. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) StartSystemVm(p interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartSystemVm", reflect.TypeOf((*MockSystemVMServiceIface)(nil).StartSystemVm), p) |
| } |
| |
| // StopSystemVm mocks base method. |
| func (m *MockSystemVMServiceIface) StopSystemVm(p *StopSystemVmParams) (*StopSystemVmResponse, error) { |
| m.ctrl.T.Helper() |
| ret := m.ctrl.Call(m, "StopSystemVm", p) |
| ret0, _ := ret[0].(*StopSystemVmResponse) |
| ret1, _ := ret[1].(error) |
| return ret0, ret1 |
| } |
| |
| // StopSystemVm indicates an expected call of StopSystemVm. |
| func (mr *MockSystemVMServiceIfaceMockRecorder) StopSystemVm(p interface{}) *gomock.Call { |
| mr.mock.ctrl.T.Helper() |
| return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopSystemVm", reflect.TypeOf((*MockSystemVMServiceIface)(nil).StopSystemVm), p) |
| } |