service/history/shard/context_mock.go

// The MIT License (MIT)

// Copyright (c) 2017-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.

// Code generated by MockGen. DO NOT EDIT.
// Source: context.go

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

import (
	context "context"
	reflect "reflect"
	time "time"

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

	cache "github.com/uber/cadence/common/cache"
	clock "github.com/uber/cadence/common/clock"
	cluster "github.com/uber/cadence/common/cluster"
	log "github.com/uber/cadence/common/log"
	metrics "github.com/uber/cadence/common/metrics"
	persistence "github.com/uber/cadence/common/persistence"
	types "github.com/uber/cadence/common/types"
	config "github.com/uber/cadence/service/history/config"
	engine "github.com/uber/cadence/service/history/engine"
	events "github.com/uber/cadence/service/history/events"
	resource "github.com/uber/cadence/service/history/resource"
)

// MockContext is a mock of Context interface.
type MockContext struct {
	ctrl     *gomock.Controller
	recorder *MockContextMockRecorder
}

// MockContextMockRecorder is the mock recorder for MockContext.
type MockContextMockRecorder struct {
	mock *MockContext
}

// NewMockContext creates a new mock instance.
func NewMockContext(ctrl *gomock.Controller) *MockContext {
	mock := &MockContext{ctrl: ctrl}
	mock.recorder = &MockContextMockRecorder{mock}
	return mock
}

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

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

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

// AppendHistoryV2Events mocks base method.
func (m *MockContext) AppendHistoryV2Events(ctx context.Context, request *persistence.AppendHistoryNodesRequest, domainID string, execution types.WorkflowExecution) (*persistence.AppendHistoryNodesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppendHistoryV2Events", ctx, request, domainID, execution)
	ret0, _ := ret[0].(*persistence.AppendHistoryNodesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AppendHistoryV2Events indicates an expected call of AppendHistoryV2Events.
func (mr *MockContextMockRecorder) AppendHistoryV2Events(ctx, request, domainID, execution interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendHistoryV2Events", reflect.TypeOf((*MockContext)(nil).AppendHistoryV2Events), ctx, request, domainID, execution)
}

// ConflictResolveWorkflowExecution mocks base method.
func (m *MockContext) ConflictResolveWorkflowExecution(ctx context.Context, request *persistence.ConflictResolveWorkflowExecutionRequest) (*persistence.ConflictResolveWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConflictResolveWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(*persistence.ConflictResolveWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateWorkflowExecution mocks base method.
func (m *MockContext) CreateWorkflowExecution(ctx context.Context, request *persistence.CreateWorkflowExecutionRequest) (*persistence.CreateWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(*persistence.CreateWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// DeleteTimerFailoverLevel indicates an expected call of DeleteTimerFailoverLevel.
func (mr *MockContextMockRecorder) DeleteTimerFailoverLevel(failoverID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTimerFailoverLevel", reflect.TypeOf((*MockContext)(nil).DeleteTimerFailoverLevel), failoverID)
}

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

// DeleteTransferFailoverLevel indicates an expected call of DeleteTransferFailoverLevel.
func (mr *MockContextMockRecorder) DeleteTransferFailoverLevel(failoverID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransferFailoverLevel", reflect.TypeOf((*MockContext)(nil).DeleteTransferFailoverLevel), failoverID)
}

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

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

// GenerateTransferTaskIDs mocks base method.
func (m *MockContext) GenerateTransferTaskIDs(number int) ([]int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateTransferTaskIDs", number)
	ret0, _ := ret[0].([]int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GenerateTransferTaskIDs indicates an expected call of GenerateTransferTaskIDs.
func (mr *MockContextMockRecorder) GenerateTransferTaskIDs(number interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateTransferTaskIDs", reflect.TypeOf((*MockContext)(nil).GenerateTransferTaskIDs), number)
}

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

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

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

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

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

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

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

// GetClusterReplicationLevel indicates an expected call of GetClusterReplicationLevel.
func (mr *MockContextMockRecorder) GetClusterReplicationLevel(cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterReplicationLevel", reflect.TypeOf((*MockContext)(nil).GetClusterReplicationLevel), cluster)
}

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

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

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

// GetCrossClusterProcessingQueueStates indicates an expected call of GetCrossClusterProcessingQueueStates.
func (mr *MockContextMockRecorder) GetCrossClusterProcessingQueueStates(cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCrossClusterProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).GetCrossClusterProcessingQueueStates), cluster)
}

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

// GetCurrentTime indicates an expected call of GetCurrentTime.
func (mr *MockContextMockRecorder) GetCurrentTime(cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentTime", reflect.TypeOf((*MockContext)(nil).GetCurrentTime), cluster)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetTimerClusterAckLevel indicates an expected call of GetTimerClusterAckLevel.
func (mr *MockContextMockRecorder) GetTimerClusterAckLevel(cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimerClusterAckLevel", reflect.TypeOf((*MockContext)(nil).GetTimerClusterAckLevel), cluster)
}

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

// GetTimerMaxReadLevel indicates an expected call of GetTimerMaxReadLevel.
func (mr *MockContextMockRecorder) GetTimerMaxReadLevel(cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimerMaxReadLevel", reflect.TypeOf((*MockContext)(nil).GetTimerMaxReadLevel), cluster)
}

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

// GetTimerProcessingQueueStates indicates an expected call of GetTimerProcessingQueueStates.
func (mr *MockContextMockRecorder) GetTimerProcessingQueueStates(cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimerProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).GetTimerProcessingQueueStates), cluster)
}

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

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

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

// GetTransferClusterAckLevel indicates an expected call of GetTransferClusterAckLevel.
func (mr *MockContextMockRecorder) GetTransferClusterAckLevel(cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransferClusterAckLevel", reflect.TypeOf((*MockContext)(nil).GetTransferClusterAckLevel), cluster)
}

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

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

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

// GetTransferProcessingQueueStates indicates an expected call of GetTransferProcessingQueueStates.
func (mr *MockContextMockRecorder) GetTransferProcessingQueueStates(cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransferProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).GetTransferProcessingQueueStates), cluster)
}

// GetWorkflowExecution mocks base method.
func (m *MockContext) GetWorkflowExecution(ctx context.Context, request *persistence.GetWorkflowExecutionRequest) (*persistence.GetWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(*persistence.GetWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ReplicateFailoverMarkers mocks base method.
func (m *MockContext) ReplicateFailoverMarkers(ctx context.Context, markers []*persistence.FailoverMarkerTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplicateFailoverMarkers", ctx, markers)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SetCurrentTime mocks base method.
func (m *MockContext) SetCurrentTime(cluster string, currentTime time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCurrentTime", cluster, currentTime)
}

// SetCurrentTime indicates an expected call of SetCurrentTime.
func (mr *MockContextMockRecorder) SetCurrentTime(cluster, currentTime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentTime", reflect.TypeOf((*MockContext)(nil).SetCurrentTime), cluster, currentTime)
}

// SetEngine mocks base method.
func (m *MockContext) SetEngine(arg0 engine.Engine) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetEngine", arg0)
}

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

// UpdateClusterReplicationLevel mocks base method.
func (m *MockContext) UpdateClusterReplicationLevel(cluster string, lastTaskID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateClusterReplicationLevel", cluster, lastTaskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateClusterReplicationLevel indicates an expected call of UpdateClusterReplicationLevel.
func (mr *MockContextMockRecorder) UpdateClusterReplicationLevel(cluster, lastTaskID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterReplicationLevel", reflect.TypeOf((*MockContext)(nil).UpdateClusterReplicationLevel), cluster, lastTaskID)
}

// UpdateCrossClusterProcessingQueueStates mocks base method.
func (m *MockContext) UpdateCrossClusterProcessingQueueStates(cluster string, states []*types.ProcessingQueueState) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCrossClusterProcessingQueueStates", cluster, states)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateCrossClusterProcessingQueueStates indicates an expected call of UpdateCrossClusterProcessingQueueStates.
func (mr *MockContextMockRecorder) UpdateCrossClusterProcessingQueueStates(cluster, states interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCrossClusterProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).UpdateCrossClusterProcessingQueueStates), cluster, states)
}

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

// UpdateDomainNotificationVersion indicates an expected call of UpdateDomainNotificationVersion.
func (mr *MockContextMockRecorder) UpdateDomainNotificationVersion(domainNotificationVersion interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDomainNotificationVersion", reflect.TypeOf((*MockContext)(nil).UpdateDomainNotificationVersion), domainNotificationVersion)
}

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

// UpdateTimerAckLevel indicates an expected call of UpdateTimerAckLevel.
func (mr *MockContextMockRecorder) UpdateTimerAckLevel(ackLevel interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTimerAckLevel", reflect.TypeOf((*MockContext)(nil).UpdateTimerAckLevel), ackLevel)
}

// UpdateTimerClusterAckLevel mocks base method.
func (m *MockContext) UpdateTimerClusterAckLevel(cluster string, ackLevel time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTimerClusterAckLevel", cluster, ackLevel)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTimerClusterAckLevel indicates an expected call of UpdateTimerClusterAckLevel.
func (mr *MockContextMockRecorder) UpdateTimerClusterAckLevel(cluster, ackLevel interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTimerClusterAckLevel", reflect.TypeOf((*MockContext)(nil).UpdateTimerClusterAckLevel), cluster, ackLevel)
}

// UpdateTimerFailoverLevel mocks base method.
func (m *MockContext) UpdateTimerFailoverLevel(failoverID string, level TimerFailoverLevel) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTimerFailoverLevel", failoverID, level)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTimerFailoverLevel indicates an expected call of UpdateTimerFailoverLevel.
func (mr *MockContextMockRecorder) UpdateTimerFailoverLevel(failoverID, level interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTimerFailoverLevel", reflect.TypeOf((*MockContext)(nil).UpdateTimerFailoverLevel), failoverID, level)
}

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

// UpdateTimerMaxReadLevel indicates an expected call of UpdateTimerMaxReadLevel.
func (mr *MockContextMockRecorder) UpdateTimerMaxReadLevel(cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTimerMaxReadLevel", reflect.TypeOf((*MockContext)(nil).UpdateTimerMaxReadLevel), cluster)
}

// UpdateTimerProcessingQueueStates mocks base method.
func (m *MockContext) UpdateTimerProcessingQueueStates(cluster string, states []*types.ProcessingQueueState) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTimerProcessingQueueStates", cluster, states)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTimerProcessingQueueStates indicates an expected call of UpdateTimerProcessingQueueStates.
func (mr *MockContextMockRecorder) UpdateTimerProcessingQueueStates(cluster, states interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTimerProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).UpdateTimerProcessingQueueStates), cluster, states)
}

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

// UpdateTransferAckLevel indicates an expected call of UpdateTransferAckLevel.
func (mr *MockContextMockRecorder) UpdateTransferAckLevel(ackLevel interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTransferAckLevel", reflect.TypeOf((*MockContext)(nil).UpdateTransferAckLevel), ackLevel)
}

// UpdateTransferClusterAckLevel mocks base method.
func (m *MockContext) UpdateTransferClusterAckLevel(cluster string, ackLevel int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTransferClusterAckLevel", cluster, ackLevel)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTransferClusterAckLevel indicates an expected call of UpdateTransferClusterAckLevel.
func (mr *MockContextMockRecorder) UpdateTransferClusterAckLevel(cluster, ackLevel interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTransferClusterAckLevel", reflect.TypeOf((*MockContext)(nil).UpdateTransferClusterAckLevel), cluster, ackLevel)
}

// UpdateTransferFailoverLevel mocks base method.
func (m *MockContext) UpdateTransferFailoverLevel(failoverID string, level TransferFailoverLevel) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTransferFailoverLevel", failoverID, level)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTransferFailoverLevel indicates an expected call of UpdateTransferFailoverLevel.
func (mr *MockContextMockRecorder) UpdateTransferFailoverLevel(failoverID, level interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTransferFailoverLevel", reflect.TypeOf((*MockContext)(nil).UpdateTransferFailoverLevel), failoverID, level)
}

// UpdateTransferProcessingQueueStates mocks base method.
func (m *MockContext) UpdateTransferProcessingQueueStates(cluster string, states []*types.ProcessingQueueState) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTransferProcessingQueueStates", cluster, states)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTransferProcessingQueueStates indicates an expected call of UpdateTransferProcessingQueueStates.
func (mr *MockContextMockRecorder) UpdateTransferProcessingQueueStates(cluster, states interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTransferProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).UpdateTransferProcessingQueueStates), cluster, states)
}

// UpdateWorkflowExecution mocks base method.
func (m *MockContext) UpdateWorkflowExecution(ctx context.Context, request *persistence.UpdateWorkflowExecutionRequest) (*persistence.UpdateWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(*persistence.UpdateWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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