bootstrap_mock.go

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

// Copyright (c) 2020 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 bootstrap is a generated GoMock package.
package bootstrap

import (
	"reflect"
	"time"

	"github.com/m3db/m3/src/dbnode/namespace"
	"github.com/m3db/m3/src/dbnode/persist/fs"
	"github.com/m3db/m3/src/dbnode/storage/bootstrap/result"
	"github.com/m3db/m3/src/dbnode/topology"
	"github.com/m3db/m3/src/x/context"
	"github.com/m3db/m3/src/x/ident"
	"github.com/m3db/m3/src/x/instrument"

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

// MockProcessProvider is a mock of ProcessProvider interface
type MockProcessProvider struct {
	ctrl     *gomock.Controller
	recorder *MockProcessProviderMockRecorder
}

// MockProcessProviderMockRecorder is the mock recorder for MockProcessProvider
type MockProcessProviderMockRecorder struct {
	mock *MockProcessProvider
}

// NewMockProcessProvider creates a new mock instance
func NewMockProcessProvider(ctrl *gomock.Controller) *MockProcessProvider {
	mock := &MockProcessProvider{ctrl: ctrl}
	mock.recorder = &MockProcessProviderMockRecorder{mock}
	return mock
}

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

// SetBootstrapperProvider mocks base method
func (m *MockProcessProvider) SetBootstrapperProvider(bootstrapper BootstrapperProvider) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBootstrapperProvider", bootstrapper)
}

// SetBootstrapperProvider indicates an expected call of SetBootstrapperProvider
func (mr *MockProcessProviderMockRecorder) SetBootstrapperProvider(bootstrapper interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBootstrapperProvider", reflect.TypeOf((*MockProcessProvider)(nil).SetBootstrapperProvider), bootstrapper)
}

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

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

// Provide mocks base method
func (m *MockProcessProvider) Provide() (Process, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Provide")
	ret0, _ := ret[0].(Process)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockProcess is a mock of Process interface
type MockProcess struct {
	ctrl     *gomock.Controller
	recorder *MockProcessMockRecorder
}

// MockProcessMockRecorder is the mock recorder for MockProcess
type MockProcessMockRecorder struct {
	mock *MockProcess
}

// NewMockProcess creates a new mock instance
func NewMockProcess(ctrl *gomock.Controller) *MockProcess {
	mock := &MockProcess{ctrl: ctrl}
	mock.recorder = &MockProcessMockRecorder{mock}
	return mock
}

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

// Run mocks base method
func (m *MockProcess) Run(ctx context.Context, start time.Time, namespaces []ProcessNamespace) (NamespaceResults, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Run", ctx, start, namespaces)
	ret0, _ := ret[0].(NamespaceResults)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Run indicates an expected call of Run
func (mr *MockProcessMockRecorder) Run(ctx, start, namespaces interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockProcess)(nil).Run), ctx, start, namespaces)
}

// MockHook is a mock of Hook interface
type MockHook struct {
	ctrl     *gomock.Controller
	recorder *MockHookMockRecorder
}

// MockHookMockRecorder is the mock recorder for MockHook
type MockHookMockRecorder struct {
	mock *MockHook
}

// NewMockHook creates a new mock instance
func NewMockHook(ctrl *gomock.Controller) *MockHook {
	mock := &MockHook{ctrl: ctrl}
	mock.recorder = &MockHookMockRecorder{mock}
	return mock
}

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

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

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

// MockNamespaceDataAccumulator is a mock of NamespaceDataAccumulator interface
type MockNamespaceDataAccumulator struct {
	ctrl     *gomock.Controller
	recorder *MockNamespaceDataAccumulatorMockRecorder
}

// MockNamespaceDataAccumulatorMockRecorder is the mock recorder for MockNamespaceDataAccumulator
type MockNamespaceDataAccumulatorMockRecorder struct {
	mock *MockNamespaceDataAccumulator
}

// NewMockNamespaceDataAccumulator creates a new mock instance
func NewMockNamespaceDataAccumulator(ctrl *gomock.Controller) *MockNamespaceDataAccumulator {
	mock := &MockNamespaceDataAccumulator{ctrl: ctrl}
	mock.recorder = &MockNamespaceDataAccumulatorMockRecorder{mock}
	return mock
}

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

// CheckoutSeriesWithoutLock mocks base method
func (m *MockNamespaceDataAccumulator) CheckoutSeriesWithoutLock(shardID uint32, id ident.ID, tags ident.TagIterator) (CheckoutSeriesResult, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckoutSeriesWithoutLock", shardID, id, tags)
	ret0, _ := ret[0].(CheckoutSeriesResult)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CheckoutSeriesWithoutLock indicates an expected call of CheckoutSeriesWithoutLock
func (mr *MockNamespaceDataAccumulatorMockRecorder) CheckoutSeriesWithoutLock(shardID, id, tags interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckoutSeriesWithoutLock", reflect.TypeOf((*MockNamespaceDataAccumulator)(nil).CheckoutSeriesWithoutLock), shardID, id, tags)
}

// CheckoutSeriesWithLock mocks base method
func (m *MockNamespaceDataAccumulator) CheckoutSeriesWithLock(shardID uint32, id ident.ID, tags ident.TagIterator) (CheckoutSeriesResult, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckoutSeriesWithLock", shardID, id, tags)
	ret0, _ := ret[0].(CheckoutSeriesResult)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CheckoutSeriesWithLock indicates an expected call of CheckoutSeriesWithLock
func (mr *MockNamespaceDataAccumulatorMockRecorder) CheckoutSeriesWithLock(shardID, id, tags interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckoutSeriesWithLock", reflect.TypeOf((*MockNamespaceDataAccumulator)(nil).CheckoutSeriesWithLock), shardID, id, tags)
}

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

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

// MockProcessOptions is a mock of ProcessOptions interface
type MockProcessOptions struct {
	ctrl     *gomock.Controller
	recorder *MockProcessOptionsMockRecorder
}

// MockProcessOptionsMockRecorder is the mock recorder for MockProcessOptions
type MockProcessOptionsMockRecorder struct {
	mock *MockProcessOptions
}

// NewMockProcessOptions creates a new mock instance
func NewMockProcessOptions(ctrl *gomock.Controller) *MockProcessOptions {
	mock := &MockProcessOptions{ctrl: ctrl}
	mock.recorder = &MockProcessOptionsMockRecorder{mock}
	return mock
}

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

// SetCacheSeriesMetadata mocks base method
func (m *MockProcessOptions) SetCacheSeriesMetadata(value bool) ProcessOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetCacheSeriesMetadata", value)
	ret0, _ := ret[0].(ProcessOptions)
	return ret0
}

// SetCacheSeriesMetadata indicates an expected call of SetCacheSeriesMetadata
func (mr *MockProcessOptionsMockRecorder) SetCacheSeriesMetadata(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCacheSeriesMetadata", reflect.TypeOf((*MockProcessOptions)(nil).SetCacheSeriesMetadata), value)
}

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

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

// SetTopologyMapProvider mocks base method
func (m *MockProcessOptions) SetTopologyMapProvider(value topology.MapProvider) ProcessOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetTopologyMapProvider", value)
	ret0, _ := ret[0].(ProcessOptions)
	return ret0
}

// SetTopologyMapProvider indicates an expected call of SetTopologyMapProvider
func (mr *MockProcessOptionsMockRecorder) SetTopologyMapProvider(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTopologyMapProvider", reflect.TypeOf((*MockProcessOptions)(nil).SetTopologyMapProvider), value)
}

// TopologyMapProvider mocks base method
func (m *MockProcessOptions) TopologyMapProvider() topology.MapProvider {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TopologyMapProvider")
	ret0, _ := ret[0].(topology.MapProvider)
	return ret0
}

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

// SetOrigin mocks base method
func (m *MockProcessOptions) SetOrigin(value topology.Host) ProcessOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetOrigin", value)
	ret0, _ := ret[0].(ProcessOptions)
	return ret0
}

// SetOrigin indicates an expected call of SetOrigin
func (mr *MockProcessOptionsMockRecorder) SetOrigin(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOrigin", reflect.TypeOf((*MockProcessOptions)(nil).SetOrigin), value)
}

// Origin mocks base method
func (m *MockProcessOptions) Origin() topology.Host {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Origin")
	ret0, _ := ret[0].(topology.Host)
	return ret0
}

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

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

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

// MockRunOptions is a mock of RunOptions interface
type MockRunOptions struct {
	ctrl     *gomock.Controller
	recorder *MockRunOptionsMockRecorder
}

// MockRunOptionsMockRecorder is the mock recorder for MockRunOptions
type MockRunOptionsMockRecorder struct {
	mock *MockRunOptions
}

// NewMockRunOptions creates a new mock instance
func NewMockRunOptions(ctrl *gomock.Controller) *MockRunOptions {
	mock := &MockRunOptions{ctrl: ctrl}
	mock.recorder = &MockRunOptionsMockRecorder{mock}
	return mock
}

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

// SetPersistConfig mocks base method
func (m *MockRunOptions) SetPersistConfig(value PersistConfig) RunOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPersistConfig", value)
	ret0, _ := ret[0].(RunOptions)
	return ret0
}

// SetPersistConfig indicates an expected call of SetPersistConfig
func (mr *MockRunOptionsMockRecorder) SetPersistConfig(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPersistConfig", reflect.TypeOf((*MockRunOptions)(nil).SetPersistConfig), value)
}

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

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

// SetCacheSeriesMetadata mocks base method
func (m *MockRunOptions) SetCacheSeriesMetadata(value bool) RunOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetCacheSeriesMetadata", value)
	ret0, _ := ret[0].(RunOptions)
	return ret0
}

// SetCacheSeriesMetadata indicates an expected call of SetCacheSeriesMetadata
func (mr *MockRunOptionsMockRecorder) SetCacheSeriesMetadata(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCacheSeriesMetadata", reflect.TypeOf((*MockRunOptions)(nil).SetCacheSeriesMetadata), value)
}

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

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

// SetInitialTopologyState mocks base method
func (m *MockRunOptions) SetInitialTopologyState(value *topology.StateSnapshot) RunOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetInitialTopologyState", value)
	ret0, _ := ret[0].(RunOptions)
	return ret0
}

// SetInitialTopologyState indicates an expected call of SetInitialTopologyState
func (mr *MockRunOptionsMockRecorder) SetInitialTopologyState(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInitialTopologyState", reflect.TypeOf((*MockRunOptions)(nil).SetInitialTopologyState), value)
}

// InitialTopologyState mocks base method
func (m *MockRunOptions) InitialTopologyState() *topology.StateSnapshot {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InitialTopologyState")
	ret0, _ := ret[0].(*topology.StateSnapshot)
	return ret0
}

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

// MockBootstrapperProvider is a mock of BootstrapperProvider interface
type MockBootstrapperProvider struct {
	ctrl     *gomock.Controller
	recorder *MockBootstrapperProviderMockRecorder
}

// MockBootstrapperProviderMockRecorder is the mock recorder for MockBootstrapperProvider
type MockBootstrapperProviderMockRecorder struct {
	mock *MockBootstrapperProvider
}

// NewMockBootstrapperProvider creates a new mock instance
func NewMockBootstrapperProvider(ctrl *gomock.Controller) *MockBootstrapperProvider {
	mock := &MockBootstrapperProvider{ctrl: ctrl}
	mock.recorder = &MockBootstrapperProviderMockRecorder{mock}
	return mock
}

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

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

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

// Provide mocks base method
func (m *MockBootstrapperProvider) Provide() (Bootstrapper, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Provide")
	ret0, _ := ret[0].(Bootstrapper)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockBootstrapper is a mock of Bootstrapper interface
type MockBootstrapper struct {
	ctrl     *gomock.Controller
	recorder *MockBootstrapperMockRecorder
}

// MockBootstrapperMockRecorder is the mock recorder for MockBootstrapper
type MockBootstrapperMockRecorder struct {
	mock *MockBootstrapper
}

// NewMockBootstrapper creates a new mock instance
func NewMockBootstrapper(ctrl *gomock.Controller) *MockBootstrapper {
	mock := &MockBootstrapper{ctrl: ctrl}
	mock.recorder = &MockBootstrapperMockRecorder{mock}
	return mock
}

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

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

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

// Bootstrap mocks base method
func (m *MockBootstrapper) Bootstrap(ctx context.Context, namespaces Namespaces, cache Cache) (NamespaceResults, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Bootstrap", ctx, namespaces, cache)
	ret0, _ := ret[0].(NamespaceResults)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Bootstrap indicates an expected call of Bootstrap
func (mr *MockBootstrapperMockRecorder) Bootstrap(ctx, namespaces, cache interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bootstrap", reflect.TypeOf((*MockBootstrapper)(nil).Bootstrap), ctx, namespaces, cache)
}

// MockSource is a mock of Source interface
type MockSource struct {
	ctrl     *gomock.Controller
	recorder *MockSourceMockRecorder
}

// MockSourceMockRecorder is the mock recorder for MockSource
type MockSourceMockRecorder struct {
	mock *MockSource
}

// NewMockSource creates a new mock instance
func NewMockSource(ctrl *gomock.Controller) *MockSource {
	mock := &MockSource{ctrl: ctrl}
	mock.recorder = &MockSourceMockRecorder{mock}
	return mock
}

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

// AvailableData mocks base method
func (m *MockSource) AvailableData(ns namespace.Metadata, shardsTimeRanges result.ShardTimeRanges, cache Cache, runOpts RunOptions) (result.ShardTimeRanges, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AvailableData", ns, shardsTimeRanges, cache, runOpts)
	ret0, _ := ret[0].(result.ShardTimeRanges)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AvailableData indicates an expected call of AvailableData
func (mr *MockSourceMockRecorder) AvailableData(ns, shardsTimeRanges, cache, runOpts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AvailableData", reflect.TypeOf((*MockSource)(nil).AvailableData), ns, shardsTimeRanges, cache, runOpts)
}

// AvailableIndex mocks base method
func (m *MockSource) AvailableIndex(ns namespace.Metadata, shardsTimeRanges result.ShardTimeRanges, cache Cache, opts RunOptions) (result.ShardTimeRanges, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AvailableIndex", ns, shardsTimeRanges, cache, opts)
	ret0, _ := ret[0].(result.ShardTimeRanges)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AvailableIndex indicates an expected call of AvailableIndex
func (mr *MockSourceMockRecorder) AvailableIndex(ns, shardsTimeRanges, cache, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AvailableIndex", reflect.TypeOf((*MockSource)(nil).AvailableIndex), ns, shardsTimeRanges, cache, opts)
}

// Read mocks base method
func (m *MockSource) Read(ctx context.Context, namespaces Namespaces, cache Cache) (NamespaceResults, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", ctx, namespaces, cache)
	ret0, _ := ret[0].(NamespaceResults)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read
func (mr *MockSourceMockRecorder) Read(ctx, namespaces, cache interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockSource)(nil).Read), ctx, namespaces, cache)
}

// MockCache is a mock of Cache interface
type MockCache struct {
	ctrl     *gomock.Controller
	recorder *MockCacheMockRecorder
}

// MockCacheMockRecorder is the mock recorder for MockCache
type MockCacheMockRecorder struct {
	mock *MockCache
}

// NewMockCache creates a new mock instance
func NewMockCache(ctrl *gomock.Controller) *MockCache {
	mock := &MockCache{ctrl: ctrl}
	mock.recorder = &MockCacheMockRecorder{mock}
	return mock
}

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

// InfoFilesForNamespace mocks base method
func (m *MockCache) InfoFilesForNamespace(ns namespace.Metadata) (InfoFileResultsPerShard, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InfoFilesForNamespace", ns)
	ret0, _ := ret[0].(InfoFileResultsPerShard)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InfoFilesForNamespace indicates an expected call of InfoFilesForNamespace
func (mr *MockCacheMockRecorder) InfoFilesForNamespace(ns interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InfoFilesForNamespace", reflect.TypeOf((*MockCache)(nil).InfoFilesForNamespace), ns)
}

// InfoFilesForShard mocks base method
func (m *MockCache) InfoFilesForShard(ns namespace.Metadata, shard uint32) ([]fs.ReadInfoFileResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InfoFilesForShard", ns, shard)
	ret0, _ := ret[0].([]fs.ReadInfoFileResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InfoFilesForShard indicates an expected call of InfoFilesForShard
func (mr *MockCacheMockRecorder) InfoFilesForShard(ns, shard interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InfoFilesForShard", reflect.TypeOf((*MockCache)(nil).InfoFilesForShard), ns, shard)
}

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

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

// MockCacheOptions is a mock of CacheOptions interface
type MockCacheOptions struct {
	ctrl     *gomock.Controller
	recorder *MockCacheOptionsMockRecorder
}

// MockCacheOptionsMockRecorder is the mock recorder for MockCacheOptions
type MockCacheOptionsMockRecorder struct {
	mock *MockCacheOptions
}

// NewMockCacheOptions creates a new mock instance
func NewMockCacheOptions(ctrl *gomock.Controller) *MockCacheOptions {
	mock := &MockCacheOptions{ctrl: ctrl}
	mock.recorder = &MockCacheOptionsMockRecorder{mock}
	return mock
}

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

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

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

// SetFilesystemOptions mocks base method
func (m *MockCacheOptions) SetFilesystemOptions(value fs.Options) CacheOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetFilesystemOptions", value)
	ret0, _ := ret[0].(CacheOptions)
	return ret0
}

// SetFilesystemOptions indicates an expected call of SetFilesystemOptions
func (mr *MockCacheOptionsMockRecorder) SetFilesystemOptions(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFilesystemOptions", reflect.TypeOf((*MockCacheOptions)(nil).SetFilesystemOptions), value)
}

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

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

// SetNamespaceDetails mocks base method
func (m *MockCacheOptions) SetNamespaceDetails(value []NamespaceDetails) CacheOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetNamespaceDetails", value)
	ret0, _ := ret[0].(CacheOptions)
	return ret0
}

// SetNamespaceDetails indicates an expected call of SetNamespaceDetails
func (mr *MockCacheOptionsMockRecorder) SetNamespaceDetails(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNamespaceDetails", reflect.TypeOf((*MockCacheOptions)(nil).SetNamespaceDetails), value)
}

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

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

// SetInstrumentOptions mocks base method
func (m *MockCacheOptions) SetInstrumentOptions(value instrument.Options) CacheOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetInstrumentOptions", value)
	ret0, _ := ret[0].(CacheOptions)
	return ret0
}

// SetInstrumentOptions indicates an expected call of SetInstrumentOptions
func (mr *MockCacheOptionsMockRecorder) SetInstrumentOptions(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstrumentOptions", reflect.TypeOf((*MockCacheOptions)(nil).SetInstrumentOptions), value)
}

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

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