github.com/m3db/m3@v1.5.0/src/dbnode/storage/limits/permits/permits_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/m3db/m3/src/dbnode/storage/limits/permits/types.go

// Copyright (c) 2021 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

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

import (
	"reflect"

	"github.com/m3db/m3/src/x/context"

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

// MockOptions is a mock of Options interface.
type MockOptions struct {
	ctrl     *gomock.Controller
	recorder *MockOptionsMockRecorder
}

// MockOptionsMockRecorder is the mock recorder for MockOptions.
type MockOptionsMockRecorder struct {
	mock *MockOptions
}

// NewMockOptions creates a new mock instance.
func NewMockOptions(ctrl *gomock.Controller) *MockOptions {
	mock := &MockOptions{ctrl: ctrl}
	mock.recorder = &MockOptionsMockRecorder{mock}
	return mock
}

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

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

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

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

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

// SetIndexQueryPermitsManager mocks base method.
func (m *MockOptions) SetIndexQueryPermitsManager(manager Manager) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIndexQueryPermitsManager", manager)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetIndexQueryPermitsManager indicates an expected call of SetIndexQueryPermitsManager.
func (mr *MockOptionsMockRecorder) SetIndexQueryPermitsManager(manager interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIndexQueryPermitsManager", reflect.TypeOf((*MockOptions)(nil).SetIndexQueryPermitsManager), manager)
}

// SetSeriesReadPermitsManager mocks base method.
func (m *MockOptions) SetSeriesReadPermitsManager(manager Manager) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetSeriesReadPermitsManager", manager)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetSeriesReadPermitsManager indicates an expected call of SetSeriesReadPermitsManager.
func (mr *MockOptionsMockRecorder) SetSeriesReadPermitsManager(manager interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSeriesReadPermitsManager", reflect.TypeOf((*MockOptions)(nil).SetSeriesReadPermitsManager), manager)
}

// MockManager is a mock of Manager interface.
type MockManager struct {
	ctrl     *gomock.Controller
	recorder *MockManagerMockRecorder
}

// MockManagerMockRecorder is the mock recorder for MockManager.
type MockManagerMockRecorder struct {
	mock *MockManager
}

// NewMockManager creates a new mock instance.
func NewMockManager(ctrl *gomock.Controller) *MockManager {
	mock := &MockManager{ctrl: ctrl}
	mock.recorder = &MockManagerMockRecorder{mock}
	return mock
}

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

// NewPermits mocks base method.
func (m *MockManager) NewPermits(ctx context.Context) (Permits, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewPermits", ctx)
	ret0, _ := ret[0].(Permits)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewPermits indicates an expected call of NewPermits.
func (mr *MockManagerMockRecorder) NewPermits(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewPermits", reflect.TypeOf((*MockManager)(nil).NewPermits), ctx)
}

// MockPermits is a mock of Permits interface.
type MockPermits struct {
	ctrl     *gomock.Controller
	recorder *MockPermitsMockRecorder
}

// MockPermitsMockRecorder is the mock recorder for MockPermits.
type MockPermitsMockRecorder struct {
	mock *MockPermits
}

// NewMockPermits creates a new mock instance.
func NewMockPermits(ctrl *gomock.Controller) *MockPermits {
	mock := &MockPermits{ctrl: ctrl}
	mock.recorder = &MockPermitsMockRecorder{mock}
	return mock
}

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

// Acquire mocks base method.
func (m *MockPermits) Acquire(ctx context.Context) (AcquireResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Acquire", ctx)
	ret0, _ := ret[0].(AcquireResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Acquire indicates an expected call of Acquire.
func (mr *MockPermitsMockRecorder) Acquire(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Acquire", reflect.TypeOf((*MockPermits)(nil).Acquire), ctx)
}

// Close mocks base method.
func (m *MockPermits) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

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

// Release mocks base method.
func (m *MockPermits) Release(permit Permit) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Release", permit)
}

// Release indicates an expected call of Release.
func (mr *MockPermitsMockRecorder) Release(permit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Release", reflect.TypeOf((*MockPermits)(nil).Release), permit)
}

// TryAcquire mocks base method.
func (m *MockPermits) TryAcquire(ctx context.Context) (Permit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TryAcquire", ctx)
	ret0, _ := ret[0].(Permit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TryAcquire indicates an expected call of TryAcquire.
func (mr *MockPermitsMockRecorder) TryAcquire(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryAcquire", reflect.TypeOf((*MockPermits)(nil).TryAcquire), ctx)
}

// MockPermit is a mock of Permit interface.
type MockPermit struct {
	ctrl     *gomock.Controller
	recorder *MockPermitMockRecorder
}

// MockPermitMockRecorder is the mock recorder for MockPermit.
type MockPermitMockRecorder struct {
	mock *MockPermit
}

// NewMockPermit creates a new mock instance.
func NewMockPermit(ctrl *gomock.Controller) *MockPermit {
	mock := &MockPermit{ctrl: ctrl}
	mock.recorder = &MockPermitMockRecorder{mock}
	return mock
}

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

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

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

// PostRelease mocks base method.
func (m *MockPermit) PostRelease() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PostRelease")
}

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

// PreAcquire mocks base method.
func (m *MockPermit) PreAcquire() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PreAcquire")
}

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

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

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

// Use mocks base method.
func (m *MockPermit) Use(quota int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Use", quota)
}

// Use indicates an expected call of Use.
func (mr *MockPermitMockRecorder) Use(quota interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Use", reflect.TypeOf((*MockPermit)(nil).Use), quota)
}