github.com/m3db/m3@v1.5.0/src/query/storage/m3/m3_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/m3db/m3/src/query/storage/m3 (interfaces: Storage,ClusterNamespace,Clusters)

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

import (
	"context"
	"reflect"
	"time"

	"github.com/m3db/m3/src/dbnode/client"
	"github.com/m3db/m3/src/query/block"
	"github.com/m3db/m3/src/query/storage"
	"github.com/m3db/m3/src/query/storage/m3/consolidators"
	"github.com/m3db/m3/src/query/storage/m3/storagemetadata"
	"github.com/m3db/m3/src/x/ident"

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

// MockStorage is a mock of Storage interface.
type MockStorage struct {
	ctrl     *gomock.Controller
	recorder *MockStorageMockRecorder
}

// MockStorageMockRecorder is the mock recorder for MockStorage.
type MockStorageMockRecorder struct {
	mock *MockStorage
}

// NewMockStorage creates a new mock instance.
func NewMockStorage(ctrl *gomock.Controller) *MockStorage {
	mock := &MockStorage{ctrl: ctrl}
	mock.recorder = &MockStorageMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockStorage) 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 *MockStorageMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStorage)(nil).Close))
}

// CompleteTags mocks base method.
func (m *MockStorage) CompleteTags(arg0 context.Context, arg1 *storage.CompleteTagsQuery, arg2 *storage.FetchOptions) (*consolidators.CompleteTagsResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteTags", arg0, arg1, arg2)
	ret0, _ := ret[0].(*consolidators.CompleteTagsResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CompleteTags indicates an expected call of CompleteTags.
func (mr *MockStorageMockRecorder) CompleteTags(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteTags", reflect.TypeOf((*MockStorage)(nil).CompleteTags), arg0, arg1, arg2)
}

// CompleteTagsCompressed mocks base method.
func (m *MockStorage) CompleteTagsCompressed(arg0 context.Context, arg1 *storage.CompleteTagsQuery, arg2 *storage.FetchOptions) (*consolidators.CompleteTagsResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteTagsCompressed", arg0, arg1, arg2)
	ret0, _ := ret[0].(*consolidators.CompleteTagsResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CompleteTagsCompressed indicates an expected call of CompleteTagsCompressed.
func (mr *MockStorageMockRecorder) CompleteTagsCompressed(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteTagsCompressed", reflect.TypeOf((*MockStorage)(nil).CompleteTagsCompressed), arg0, arg1, arg2)
}

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

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

// FetchBlocks mocks base method.
func (m *MockStorage) FetchBlocks(arg0 context.Context, arg1 *storage.FetchQuery, arg2 *storage.FetchOptions) (block.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchBlocks", arg0, arg1, arg2)
	ret0, _ := ret[0].(block.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchBlocks indicates an expected call of FetchBlocks.
func (mr *MockStorageMockRecorder) FetchBlocks(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBlocks", reflect.TypeOf((*MockStorage)(nil).FetchBlocks), arg0, arg1, arg2)
}

// FetchCompressed mocks base method.
func (m *MockStorage) FetchCompressed(arg0 context.Context, arg1 *storage.FetchQuery, arg2 *storage.FetchOptions) (consolidators.MultiFetchResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchCompressed", arg0, arg1, arg2)
	ret0, _ := ret[0].(consolidators.MultiFetchResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchCompressed indicates an expected call of FetchCompressed.
func (mr *MockStorageMockRecorder) FetchCompressed(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchCompressed", reflect.TypeOf((*MockStorage)(nil).FetchCompressed), arg0, arg1, arg2)
}

// FetchCompressedResult mocks base method.
func (m *MockStorage) FetchCompressedResult(arg0 context.Context, arg1 *storage.FetchQuery, arg2 *storage.FetchOptions) (consolidators.SeriesFetchResult, Cleanup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchCompressedResult", arg0, arg1, arg2)
	ret0, _ := ret[0].(consolidators.SeriesFetchResult)
	ret1, _ := ret[1].(Cleanup)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FetchCompressedResult indicates an expected call of FetchCompressedResult.
func (mr *MockStorageMockRecorder) FetchCompressedResult(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchCompressedResult", reflect.TypeOf((*MockStorage)(nil).FetchCompressedResult), arg0, arg1, arg2)
}

// FetchProm mocks base method.
func (m *MockStorage) FetchProm(arg0 context.Context, arg1 *storage.FetchQuery, arg2 *storage.FetchOptions) (storage.PromResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchProm", arg0, arg1, arg2)
	ret0, _ := ret[0].(storage.PromResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchProm indicates an expected call of FetchProm.
func (mr *MockStorageMockRecorder) FetchProm(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchProm", reflect.TypeOf((*MockStorage)(nil).FetchProm), arg0, arg1, arg2)
}

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

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

// QueryStorageMetadataAttributes mocks base method.
func (m *MockStorage) QueryStorageMetadataAttributes(arg0 context.Context, arg1, arg2 time.Time, arg3 *storage.FetchOptions) ([]storagemetadata.Attributes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryStorageMetadataAttributes", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]storagemetadata.Attributes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryStorageMetadataAttributes indicates an expected call of QueryStorageMetadataAttributes.
func (mr *MockStorageMockRecorder) QueryStorageMetadataAttributes(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryStorageMetadataAttributes", reflect.TypeOf((*MockStorage)(nil).QueryStorageMetadataAttributes), arg0, arg1, arg2, arg3)
}

// SearchCompressed mocks base method.
func (m *MockStorage) SearchCompressed(arg0 context.Context, arg1 *storage.FetchQuery, arg2 *storage.FetchOptions) (consolidators.TagResult, Cleanup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchCompressed", arg0, arg1, arg2)
	ret0, _ := ret[0].(consolidators.TagResult)
	ret1, _ := ret[1].(Cleanup)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SearchCompressed indicates an expected call of SearchCompressed.
func (mr *MockStorageMockRecorder) SearchCompressed(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchCompressed", reflect.TypeOf((*MockStorage)(nil).SearchCompressed), arg0, arg1, arg2)
}

// SearchSeries mocks base method.
func (m *MockStorage) SearchSeries(arg0 context.Context, arg1 *storage.FetchQuery, arg2 *storage.FetchOptions) (*storage.SearchResults, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchSeries", arg0, arg1, arg2)
	ret0, _ := ret[0].(*storage.SearchResults)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchSeries indicates an expected call of SearchSeries.
func (mr *MockStorageMockRecorder) SearchSeries(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSeries", reflect.TypeOf((*MockStorage)(nil).SearchSeries), arg0, arg1, arg2)
}

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

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

// Write mocks base method.
func (m *MockStorage) Write(arg0 context.Context, arg1 *storage.WriteQuery) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Write indicates an expected call of Write.
func (mr *MockStorageMockRecorder) Write(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockStorage)(nil).Write), arg0, arg1)
}

// MockClusterNamespace is a mock of ClusterNamespace interface.
type MockClusterNamespace struct {
	ctrl     *gomock.Controller
	recorder *MockClusterNamespaceMockRecorder
}

// MockClusterNamespaceMockRecorder is the mock recorder for MockClusterNamespace.
type MockClusterNamespaceMockRecorder struct {
	mock *MockClusterNamespace
}

// NewMockClusterNamespace creates a new mock instance.
func NewMockClusterNamespace(ctrl *gomock.Controller) *MockClusterNamespace {
	mock := &MockClusterNamespace{ctrl: ctrl}
	mock.recorder = &MockClusterNamespaceMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// MockClusters is a mock of Clusters interface.
type MockClusters struct {
	ctrl     *gomock.Controller
	recorder *MockClustersMockRecorder
}

// MockClustersMockRecorder is the mock recorder for MockClusters.
type MockClustersMockRecorder struct {
	mock *MockClusters
}

// NewMockClusters creates a new mock instance.
func NewMockClusters(ctrl *gomock.Controller) *MockClusters {
	mock := &MockClusters{ctrl: ctrl}
	mock.recorder = &MockClustersMockRecorder{mock}
	return mock
}

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

// AggregatedClusterNamespace mocks base method.
func (m *MockClusters) AggregatedClusterNamespace(arg0 RetentionResolution) (ClusterNamespace, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AggregatedClusterNamespace", arg0)
	ret0, _ := ret[0].(ClusterNamespace)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// AggregatedClusterNamespace indicates an expected call of AggregatedClusterNamespace.
func (mr *MockClustersMockRecorder) AggregatedClusterNamespace(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AggregatedClusterNamespace", reflect.TypeOf((*MockClusters)(nil).AggregatedClusterNamespace), arg0)
}

// Close mocks base method.
func (m *MockClusters) 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 *MockClustersMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClusters)(nil).Close))
}

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

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

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

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

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

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

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

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