From eb3b02d82eaa83a8c81278eb475eaec89df3084e Mon Sep 17 00:00:00 2001 From: David Porter Date: Wed, 6 Mar 2024 15:30:25 -0800 Subject: [PATCH 1/2] Adds MSB tests --- .../execution/mutable_state_builder_test.go | 275 ++++++ service/history/shard/context.go | 2 + service/history/shard/interface_mock.go | 844 ++++++++++++++++++ 3 files changed, 1121 insertions(+) create mode 100644 service/history/shard/interface_mock.go diff --git a/service/history/execution/mutable_state_builder_test.go b/service/history/execution/mutable_state_builder_test.go index 1990c955cf4..98e276dfcc9 100644 --- a/service/history/execution/mutable_state_builder_test.go +++ b/service/history/execution/mutable_state_builder_test.go @@ -21,6 +21,8 @@ package execution import ( + "context" + "errors" "testing" "time" @@ -37,12 +39,14 @@ import ( "github.com/uber/cadence/common/definition" "github.com/uber/cadence/common/dynamicconfig" "github.com/uber/cadence/common/log" + "github.com/uber/cadence/common/metrics" "github.com/uber/cadence/common/persistence" "github.com/uber/cadence/common/types" "github.com/uber/cadence/service/history/config" "github.com/uber/cadence/service/history/constants" "github.com/uber/cadence/service/history/events" "github.com/uber/cadence/service/history/shard" + shardCtx "github.com/uber/cadence/service/history/shard" ) type ( @@ -990,3 +994,274 @@ func (s *mutableStateSuite) buildWorkflowMutableState() *persistence.WorkflowMut VersionHistories: versionHistories, } } + +func TestNewMutableStateBuilderWithEventV2(t *testing.T) { + + ctrl := gomock.NewController(t) + mockShard := shard.NewTestContext( + t, + ctrl, + &persistence.ShardInfo{ + ShardID: 0, + RangeID: 1, + TransferAckLevel: 0, + }, + config.NewForTest(), + ) + domainCache := cache.NewDomainCacheEntryForTest( + &persistence.DomainInfo{Name: "mutableStateTest"}, + &persistence.DomainConfig{}, + true, + &persistence.DomainReplicationConfig{}, + 1, + nil, + ) + + NewMutableStateBuilderWithEventV2(mockShard, log.NewNoop(), "A82146B5-7A5C-4660-9195-E80E5161EC56", domainCache) +} + +var ( + domainID = "A6338800-D143-4FEF-8A49-9BBB31386C5F" + wfID = "879A361B-B435-491D-8A3B-ACF3BAD30F4B" + runID = "81DFCB6B-ACD4-46D1-89C2-804388203880" + ts1 = int64(1234) + shardID = 123 +) + +// Guiding real data example: ie: +// `select execution from executions where run_id = ALLOW FILTERING;` +// +// executions.execution { +// domainID: "A6338800-D143-4FEF-8A49-9BBB31386C5F", +// wfID: "879A361B-B435-491D-8A3B-ACF3BAD30F4B", +// runID: "81DFCB6B-ACD4-46D1-89C2-804388203880", +// initiated_id: -7, +// completion_event: null, +// state: 2, +// close_status: 1, +// next_event_id: 12, +// last_processed_event: 9, +// decision_schedule_id: -23, +// decision_started_id: -23, +// last_first_event_id: 10, +// decision_version: -24, +// completion_event_batch_id: 10, +// last_event_task_id: 4194328, +// } +var exampleMutableStateForClosedWF = &mutableStateBuilder{ + executionInfo: &persistence.WorkflowExecutionInfo{ + WorkflowID: wfID, + DomainID: domainID, + RunID: runID, + NextEventID: 12, + State: persistence.WorkflowStateCompleted, + CompletionEventBatchID: 10, + BranchToken: []byte("branch-token"), + }, +} + +var exampleCompletionEvent = &types.HistoryEvent{ + ID: 11, + TaskID: 4194328, + Version: 1, + Timestamp: &ts1, + WorkflowExecutionCompletedEventAttributes: &types.WorkflowExecutionCompletedEventAttributes{ + Result: []byte("some random workflow completion result"), + DecisionTaskCompletedEventID: 10, + }, +} + +var exampleStartEvent = &types.HistoryEvent{ + ID: 1, + TaskID: 4194328, + Version: 1, + Timestamp: &ts1, + WorkflowExecutionStartedEventAttributes: &types.WorkflowExecutionStartedEventAttributes{ + WorkflowType: &types.WorkflowType{Name: "workflow-type"}, + TaskList: &types.TaskList{Name: "tasklist"}, + Input: []byte("some random workflow input"), + ExecutionStartToCloseTimeoutSeconds: common.Int32Ptr(60), + TaskStartToCloseTimeoutSeconds: common.Int32Ptr(10), + OriginalExecutionRunID: runID, + Identity: "123@some-hostname@@uuid", + }, +} + +func TestGetCompletionEvent(t *testing.T) { + + tests := map[string]struct { + currentState *mutableStateBuilder + + historyManagerAffordance func(historyManager *persistence.MockHistoryManager) + + expectedResult *types.HistoryEvent + expectedErr error + }{ + "Getting a completed event from a normal, completed workflow - taken from a real example": { + currentState: exampleMutableStateForClosedWF, + historyManagerAffordance: func(historyManager *persistence.MockHistoryManager) { + + historyManager.EXPECT().ReadHistoryBranch(gomock.Any(), + &persistence.ReadHistoryBranchRequest{ + BranchToken: []byte("branch-token"), + MinEventID: 10, + MaxEventID: 12, // nextEventID +1 + PageSize: 1, + NextPageToken: nil, + ShardID: common.IntPtr(shardID), + DomainName: "domain", + }).Return(&persistence.ReadHistoryBranchResponse{ + HistoryEvents: []*types.HistoryEvent{ + exampleCompletionEvent, + }, + }, nil) + + }, + + expectedResult: exampleCompletionEvent, + }, + "An unexpected error while fetchhing history, such as not found err": { + currentState: &mutableStateBuilder{ + executionInfo: &persistence.WorkflowExecutionInfo{ + WorkflowID: wfID, + DomainID: domainID, + RunID: runID, + NextEventID: 12, + State: persistence.WorkflowStateCompleted, + CompletionEventBatchID: 10, + BranchToken: []byte("branch-token"), + }, + }, + historyManagerAffordance: func(historyManager *persistence.MockHistoryManager) { + historyManager.EXPECT().ReadHistoryBranch(gomock.Any(), gomock.Any()).Return(nil, errors.New("a transient random error")) + }, + + expectedResult: nil, + expectedErr: &types.InternalServiceError{Message: "unable to get workflow completion event"}, + }, + "A 'transient' internal service error, this should be returned to the caller": { + currentState: &mutableStateBuilder{ + executionInfo: &persistence.WorkflowExecutionInfo{ + WorkflowID: wfID, + DomainID: domainID, + RunID: runID, + NextEventID: 12, + State: persistence.WorkflowStateCompleted, + CompletionEventBatchID: 10, + BranchToken: []byte("branch-token"), + }, + }, + historyManagerAffordance: func(historyManager *persistence.MockHistoryManager) { + historyManager.EXPECT().ReadHistoryBranch(gomock.Any(), gomock.Any()). + Return(nil, &types.InternalServiceError{Message: "an err"}) + }, + + expectedResult: nil, + expectedErr: &types.InternalServiceError{Message: "an err"}, + }, + "initial validation: An invalid starting mutable state should return an error": { + currentState: &mutableStateBuilder{ + executionInfo: &persistence.WorkflowExecutionInfo{}, + }, + historyManagerAffordance: func(historyManager *persistence.MockHistoryManager) {}, + expectedResult: nil, + expectedErr: &types.InternalServiceError{Message: "unable to get workflow completion event"}, + }, + } + + for name, td := range tests { + t.Run(name, func(t *testing.T) { + + ctrl := gomock.NewController(t) + + shardContext := shardCtx.NewMockContext(ctrl) + shardContext.EXPECT().GetShardID().Return(123).AnyTimes() // this isn't called on a few of the validation failures + historyManager := persistence.NewMockHistoryManager(ctrl) + td.historyManagerAffordance(historyManager) + + domainCache := cache.NewMockDomainCache(ctrl) + domainCache.EXPECT().GetDomainName(gomock.Any()).Return("domain", nil).AnyTimes() // this isn't called on validation + + td.currentState.eventsCache = events.NewCache(shardID, historyManager, config.NewForTest(), log.NewNoop(), metrics.NewNoopMetricsClient(), domainCache) + td.currentState.shard = shardContext + + res, err := td.currentState.GetCompletionEvent(context.Background()) + + assert.Equal(t, td.expectedResult, res) + assert.Equal(t, td.expectedErr, err) + }) + } +} + +func TestGetStartEvent(t *testing.T) { + + tests := map[string]struct { + currentState *mutableStateBuilder + + historyManagerAffordance func(historyManager *persistence.MockHistoryManager) + + expectedResult *types.HistoryEvent + expectedErr error + }{ + "Getting a start event from a normal, completed workflow - taken from a real example": { + currentState: exampleMutableStateForClosedWF, + historyManagerAffordance: func(historyManager *persistence.MockHistoryManager) { + + historyManager.EXPECT().ReadHistoryBranch(gomock.Any(), + &persistence.ReadHistoryBranchRequest{ + BranchToken: []byte("branch-token"), + MinEventID: 1, + MaxEventID: 2, + PageSize: 1, + NextPageToken: nil, + ShardID: common.IntPtr(shardID), + DomainName: "domain", + }).Return(&persistence.ReadHistoryBranchResponse{ + HistoryEvents: []*types.HistoryEvent{ + exampleStartEvent, + }, + }, nil) + + }, + + expectedResult: exampleStartEvent, + }, + "Getting a start event but hitting an error when reaching into history": { + currentState: exampleMutableStateForClosedWF, + historyManagerAffordance: func(historyManager *persistence.MockHistoryManager) { + historyManager.EXPECT().ReadHistoryBranch(gomock.Any(), gomock.Any()).Return(nil, errors.New("an error")) + }, + expectedErr: &types.InternalServiceError{Message: "unable to get workflow start event"}, + }, + "Getting a start event but hitting a 'transient' error when reaching into history. This should be passed back up the call stack": { + currentState: exampleMutableStateForClosedWF, + historyManagerAffordance: func(historyManager *persistence.MockHistoryManager) { + historyManager.EXPECT().ReadHistoryBranch(gomock.Any(), gomock.Any()).Return(nil, &types.InternalServiceError{Message: "an error"}) + }, + expectedErr: &types.InternalServiceError{Message: "an error"}, + }, + } + + for name, td := range tests { + t.Run(name, func(t *testing.T) { + + ctrl := gomock.NewController(t) + + shardContext := shardCtx.NewMockContext(ctrl) + shardContext.EXPECT().GetShardID().Return(123).AnyTimes() // this isn't called on a few of the validation failures + historyManager := persistence.NewMockHistoryManager(ctrl) + td.historyManagerAffordance(historyManager) + + domainCache := cache.NewMockDomainCache(ctrl) + domainCache.EXPECT().GetDomainName(gomock.Any()).Return("domain", nil).AnyTimes() // this isn't called on validation + + td.currentState.eventsCache = events.NewCache(shardID, historyManager, config.NewForTest(), log.NewNoop(), metrics.NewNoopMetricsClient(), domainCache) + td.currentState.shard = shardContext + + res, err := td.currentState.GetStartEvent(context.Background()) + + assert.Equal(t, td.expectedResult, res) + assert.Equal(t, td.expectedErr, err) + }) + } +} diff --git a/service/history/shard/context.go b/service/history/shard/context.go index 037a71de136..f5859446053 100644 --- a/service/history/shard/context.go +++ b/service/history/shard/context.go @@ -18,6 +18,8 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. +//go:generate mockgen -package $GOPACKAGE -source $GOFILE -destination interface_mock.go -package shard github.com/uber/cadence/history/shard/context Context + package shard import ( diff --git a/service/history/shard/interface_mock.go b/service/history/shard/interface_mock.go new file mode 100644 index 00000000000..5d870a90125 --- /dev/null +++ b/service/history/shard/interface_mock.go @@ -0,0 +1,844 @@ +// 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)) +} From addd9da20b48a1f85fb67535614416d3292984d6 Mon Sep 17 00:00:00 2001 From: David Porter Date: Wed, 6 Mar 2024 16:33:01 -0800 Subject: [PATCH 2/2] feedback --- .../execution/mutable_state_builder_test.go | 14 ++++++++------ service/history/shard/context.go | 2 +- .../shard/{interface_mock.go => context_mock.go} | 0 3 files changed, 9 insertions(+), 7 deletions(-) rename service/history/shard/{interface_mock.go => context_mock.go} (100%) diff --git a/service/history/execution/mutable_state_builder_test.go b/service/history/execution/mutable_state_builder_test.go index 98e276dfcc9..fa96f5d2465 100644 --- a/service/history/execution/mutable_state_builder_test.go +++ b/service/history/execution/mutable_state_builder_test.go @@ -1088,7 +1088,6 @@ var exampleStartEvent = &types.HistoryEvent{ } func TestGetCompletionEvent(t *testing.T) { - tests := map[string]struct { currentState *mutableStateBuilder @@ -1188,13 +1187,14 @@ func TestGetCompletionEvent(t *testing.T) { res, err := td.currentState.GetCompletionEvent(context.Background()) assert.Equal(t, td.expectedResult, res) - assert.Equal(t, td.expectedErr, err) + if td.expectedErr != nil { + assert.ErrorAs(t, td.expectedErr, &err) + } }) } } func TestGetStartEvent(t *testing.T) { - tests := map[string]struct { currentState *mutableStateBuilder @@ -1231,14 +1231,14 @@ func TestGetStartEvent(t *testing.T) { historyManagerAffordance: func(historyManager *persistence.MockHistoryManager) { historyManager.EXPECT().ReadHistoryBranch(gomock.Any(), gomock.Any()).Return(nil, errors.New("an error")) }, - expectedErr: &types.InternalServiceError{Message: "unable to get workflow start event"}, + expectedErr: types.InternalServiceError{Message: "unable to get workflow start event"}, }, "Getting a start event but hitting a 'transient' error when reaching into history. This should be passed back up the call stack": { currentState: exampleMutableStateForClosedWF, historyManagerAffordance: func(historyManager *persistence.MockHistoryManager) { historyManager.EXPECT().ReadHistoryBranch(gomock.Any(), gomock.Any()).Return(nil, &types.InternalServiceError{Message: "an error"}) }, - expectedErr: &types.InternalServiceError{Message: "an error"}, + expectedErr: types.InternalServiceError{Message: "an error"}, }, } @@ -1261,7 +1261,9 @@ func TestGetStartEvent(t *testing.T) { res, err := td.currentState.GetStartEvent(context.Background()) assert.Equal(t, td.expectedResult, res) - assert.Equal(t, td.expectedErr, err) + if td.expectedErr != nil { + assert.ErrorAs(t, err, &td.expectedErr) + } }) } } diff --git a/service/history/shard/context.go b/service/history/shard/context.go index f5859446053..26f9c4531bc 100644 --- a/service/history/shard/context.go +++ b/service/history/shard/context.go @@ -18,7 +18,7 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. -//go:generate mockgen -package $GOPACKAGE -source $GOFILE -destination interface_mock.go -package shard github.com/uber/cadence/history/shard/context Context +//go:generate mockgen -package $GOPACKAGE -source $GOFILE -destination context_mock.go -package shard github.com/uber/cadence/history/shard/context Context package shard diff --git a/service/history/shard/interface_mock.go b/service/history/shard/context_mock.go similarity index 100% rename from service/history/shard/interface_mock.go rename to service/history/shard/context_mock.go