common/persistence/data_store_interfaces_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: github.com/uber/cadence/common/persistence (interfaces: ExecutionStore)

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

import (
	context "context"
	reflect "reflect"

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

// MockExecutionStore is a mock of ExecutionStore interface.
type MockExecutionStore struct {
	ctrl     *gomock.Controller
	recorder *MockExecutionStoreMockRecorder
}

// MockExecutionStoreMockRecorder is the mock recorder for MockExecutionStore.
type MockExecutionStoreMockRecorder struct {
	mock *MockExecutionStore
}

// NewMockExecutionStore creates a new mock instance.
func NewMockExecutionStore(ctrl *gomock.Controller) *MockExecutionStore {
	mock := &MockExecutionStore{ctrl: ctrl}
	mock.recorder = &MockExecutionStoreMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// CreateWorkflowExecution mocks base method.
func (m *MockExecutionStore) CreateWorkflowExecution(arg0 context.Context, arg1 *InternalCreateWorkflowExecutionRequest) (*CreateWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWorkflowExecution", arg0, arg1)
	ret0, _ := ret[0].(*CreateWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// GetCrossClusterTasks mocks base method.
func (m *MockExecutionStore) GetCrossClusterTasks(arg0 context.Context, arg1 *GetCrossClusterTasksRequest) (*GetCrossClusterTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCrossClusterTasks", arg0, arg1)
	ret0, _ := ret[0].(*GetCrossClusterTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCurrentExecution mocks base method.
func (m *MockExecutionStore) GetCurrentExecution(arg0 context.Context, arg1 *GetCurrentExecutionRequest) (*GetCurrentExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentExecution", arg0, arg1)
	ret0, _ := ret[0].(*GetCurrentExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetReplicationDLQSize mocks base method.
func (m *MockExecutionStore) GetReplicationDLQSize(arg0 context.Context, arg1 *GetReplicationDLQSizeRequest) (*GetReplicationDLQSizeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReplicationDLQSize", arg0, arg1)
	ret0, _ := ret[0].(*GetReplicationDLQSizeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetReplicationTasks mocks base method.
func (m *MockExecutionStore) GetReplicationTasks(arg0 context.Context, arg1 *GetReplicationTasksRequest) (*InternalGetReplicationTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReplicationTasks", arg0, arg1)
	ret0, _ := ret[0].(*InternalGetReplicationTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetReplicationTasksFromDLQ mocks base method.
func (m *MockExecutionStore) GetReplicationTasksFromDLQ(arg0 context.Context, arg1 *GetReplicationTasksFromDLQRequest) (*InternalGetReplicationTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReplicationTasksFromDLQ", arg0, arg1)
	ret0, _ := ret[0].(*InternalGetReplicationTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// GetTimerIndexTasks mocks base method.
func (m *MockExecutionStore) GetTimerIndexTasks(arg0 context.Context, arg1 *GetTimerIndexTasksRequest) (*GetTimerIndexTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimerIndexTasks", arg0, arg1)
	ret0, _ := ret[0].(*GetTimerIndexTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTransferTasks mocks base method.
func (m *MockExecutionStore) GetTransferTasks(arg0 context.Context, arg1 *GetTransferTasksRequest) (*GetTransferTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransferTasks", arg0, arg1)
	ret0, _ := ret[0].(*GetTransferTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkflowExecution mocks base method.
func (m *MockExecutionStore) GetWorkflowExecution(arg0 context.Context, arg1 *InternalGetWorkflowExecutionRequest) (*InternalGetWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkflowExecution", arg0, arg1)
	ret0, _ := ret[0].(*InternalGetWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// IsWorkflowExecutionExists mocks base method.
func (m *MockExecutionStore) IsWorkflowExecutionExists(arg0 context.Context, arg1 *IsWorkflowExecutionExistsRequest) (*IsWorkflowExecutionExistsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsWorkflowExecutionExists", arg0, arg1)
	ret0, _ := ret[0].(*IsWorkflowExecutionExistsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListConcreteExecutions mocks base method.
func (m *MockExecutionStore) ListConcreteExecutions(arg0 context.Context, arg1 *ListConcreteExecutionsRequest) (*InternalListConcreteExecutionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListConcreteExecutions", arg0, arg1)
	ret0, _ := ret[0].(*InternalListConcreteExecutionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListCurrentExecutions mocks base method.
func (m *MockExecutionStore) ListCurrentExecutions(arg0 context.Context, arg1 *ListCurrentExecutionsRequest) (*ListCurrentExecutionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCurrentExecutions", arg0, arg1)
	ret0, _ := ret[0].(*ListCurrentExecutionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// RangeCompleteCrossClusterTask mocks base method.
func (m *MockExecutionStore) RangeCompleteCrossClusterTask(arg0 context.Context, arg1 *RangeCompleteCrossClusterTaskRequest) (*RangeCompleteCrossClusterTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeCompleteCrossClusterTask", arg0, arg1)
	ret0, _ := ret[0].(*RangeCompleteCrossClusterTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RangeCompleteReplicationTask mocks base method.
func (m *MockExecutionStore) RangeCompleteReplicationTask(arg0 context.Context, arg1 *RangeCompleteReplicationTaskRequest) (*RangeCompleteReplicationTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeCompleteReplicationTask", arg0, arg1)
	ret0, _ := ret[0].(*RangeCompleteReplicationTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RangeCompleteTimerTask mocks base method.
func (m *MockExecutionStore) RangeCompleteTimerTask(arg0 context.Context, arg1 *RangeCompleteTimerTaskRequest) (*RangeCompleteTimerTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeCompleteTimerTask", arg0, arg1)
	ret0, _ := ret[0].(*RangeCompleteTimerTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RangeCompleteTransferTask mocks base method.
func (m *MockExecutionStore) RangeCompleteTransferTask(arg0 context.Context, arg1 *RangeCompleteTransferTaskRequest) (*RangeCompleteTransferTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeCompleteTransferTask", arg0, arg1)
	ret0, _ := ret[0].(*RangeCompleteTransferTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RangeDeleteReplicationTaskFromDLQ mocks base method.
func (m *MockExecutionStore) RangeDeleteReplicationTaskFromDLQ(arg0 context.Context, arg1 *RangeDeleteReplicationTaskFromDLQRequest) (*RangeDeleteReplicationTaskFromDLQResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteReplicationTaskFromDLQ", arg0, arg1)
	ret0, _ := ret[0].(*RangeDeleteReplicationTaskFromDLQResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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