cloudstack/LimitService_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/LimitService.go

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

import (
	reflect "reflect"

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

// MockLimitServiceIface is a mock of LimitServiceIface interface.
type MockLimitServiceIface struct {
	ctrl     *gomock.Controller
	recorder *MockLimitServiceIfaceMockRecorder
}

// MockLimitServiceIfaceMockRecorder is the mock recorder for MockLimitServiceIface.
type MockLimitServiceIfaceMockRecorder struct {
	mock *MockLimitServiceIface
}

// NewMockLimitServiceIface creates a new mock instance.
func NewMockLimitServiceIface(ctrl *gomock.Controller) *MockLimitServiceIface {
	mock := &MockLimitServiceIface{ctrl: ctrl}
	mock.recorder = &MockLimitServiceIfaceMockRecorder{mock}
	return mock
}

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

// GetApiLimit mocks base method.
func (m *MockLimitServiceIface) GetApiLimit(p *GetApiLimitParams) (*GetApiLimitResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetApiLimit", p)
	ret0, _ := ret[0].(*GetApiLimitResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListResourceLimits mocks base method.
func (m *MockLimitServiceIface) ListResourceLimits(p *ListResourceLimitsParams) (*ListResourceLimitsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListResourceLimits", p)
	ret0, _ := ret[0].(*ListResourceLimitsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// NewUpdateResourceCountParams mocks base method.
func (m *MockLimitServiceIface) NewUpdateResourceCountParams(domainid string) *UpdateResourceCountParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewUpdateResourceCountParams", domainid)
	ret0, _ := ret[0].(*UpdateResourceCountParams)
	return ret0
}

// NewUpdateResourceCountParams indicates an expected call of NewUpdateResourceCountParams.
func (mr *MockLimitServiceIfaceMockRecorder) NewUpdateResourceCountParams(domainid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateResourceCountParams", reflect.TypeOf((*MockLimitServiceIface)(nil).NewUpdateResourceCountParams), domainid)
}

// NewUpdateResourceLimitParams mocks base method.
func (m *MockLimitServiceIface) NewUpdateResourceLimitParams(resourcetype int) *UpdateResourceLimitParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewUpdateResourceLimitParams", resourcetype)
	ret0, _ := ret[0].(*UpdateResourceLimitParams)
	return ret0
}

// NewUpdateResourceLimitParams indicates an expected call of NewUpdateResourceLimitParams.
func (mr *MockLimitServiceIfaceMockRecorder) NewUpdateResourceLimitParams(resourcetype interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateResourceLimitParams", reflect.TypeOf((*MockLimitServiceIface)(nil).NewUpdateResourceLimitParams), resourcetype)
}

// ResetApiLimit mocks base method.
func (m *MockLimitServiceIface) ResetApiLimit(p *ResetApiLimitParams) (*ResetApiLimitResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetApiLimit", p)
	ret0, _ := ret[0].(*ResetApiLimitResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateResourceCount mocks base method.
func (m *MockLimitServiceIface) UpdateResourceCount(p *UpdateResourceCountParams) (*UpdateResourceCountResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateResourceCount", p)
	ret0, _ := ret[0].(*UpdateResourceCountResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateResourceLimit mocks base method.
func (m *MockLimitServiceIface) UpdateResourceLimit(p *UpdateResourceLimitParams) (*UpdateResourceLimitResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateResourceLimit", p)
	ret0, _ := ret[0].(*UpdateResourceLimitResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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