mirror of
https://github.com/hanzoai/tasks.git
synced 2026-10-04 02:04:03 +00:00
1e31c76ed1
## What changed? Cherry-pick versioning PRs - #9168 - Cache for system protection - #9262 - Cache for system protection - #9239 - Critical PR to enable sending `TargetVersionChanged` flag for Upgrade-on-CaN feature - #9147 - Tracks version drainage properly when version receives workflows via `VersioningOverride`. Needed for automated worker controllers to correctly scale versioned workers that received workflows via `VersioningOverride`. - #9300 - Needed for `approximate_backlog_count` metric to track Current and Ramping version tasks correctly - #9316 - Needed for `approximate_backlog_count` metric to track Current and Ramping version tasks correctly - #8957 - Contains minor metric improvement. Included because it adds a test harness that is used in the two metrics PRs above - #9250 - Bug fix of task rescheduling edge case during AutoUpgrade Transition ## Why? For OSS v1.30.2 ## How did you test it? - [x] built - [ ] run locally and tested manually - [x] covered by existing tests - [ ] added new unit test(s) - [ ] added new functional test(s) --- > [!NOTE] > **Medium Risk** > Touches history/matching worker-versioning paths, adding new caches and changing workflow task/start handling and backlog metric emission; incorrect caching or signaling could affect dispatch/upgrade behavior and observability. > > **Overview** > Adds new worker-versioning protections and upgrade signaling: workflow task started events now persist a `workflow_task_target_worker_deployment_version_changed` flag (and emit a new `workflow_target_version_changed_count` metric) under a new `EnableSendTargetVersionChanged` dynamic config. > > Introduces two new caches with metrics and dynamic config knobs: a `RoutingInfoCache` to avoid repeated `GetTaskQueueUserData` lookups during activity start/transition logic, and a `ReactivationSignalCache` plus `EnableVersionReactivationSignals` to dedupe and asynchronously send “reactivation” signals when workflows are pinned (via start/signal-with-start/reset/update-options) to potentially drained/inactive worker versions. > > Extends matching backlog metrics to support version-attributed reporting by adding `BacklogMetricsEmitInterval` and switching queue DB emission to *physical* backlog gauges (`physical_approximate_backlog_*`) when attribution is enabled, while keeping legacy gauges when disabled. > > Adds frontend scaffolding for a new visibility RPC `CountSchedules` (client plumbing, interception/metadata/quota wiring) but leaves the frontend handler unimplemented, and bumps `go.temporal.io/api` to `v1.62.2`. > > <sup>Written by [Cursor Bugbot]() for commit cb8ae14c86666654c51dd66ae91cb225722e1ba7. This will update automatically on new commits. Configure [here]().</sup> --------- Co-authored-by: Shahab Tajik <[email protected]> Co-authored-by: Shivam <[email protected]>
3729 lines
177 KiB
Go
3729 lines
177 KiB
Go
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: mutable_state.go
|
|
//
|
|
// Generated by this command:
|
|
//
|
|
// mockgen -package interfaces -source mutable_state.go -destination mutable_state_mock.go
|
|
//
|
|
|
|
// Package interfaces is a generated GoMock package.
|
|
package interfaces
|
|
|
|
import (
|
|
context "context"
|
|
reflect "reflect"
|
|
time "time"
|
|
|
|
command "go.temporal.io/api/command/v1"
|
|
common "go.temporal.io/api/common/v1"
|
|
deployment "go.temporal.io/api/deployment/v1"
|
|
enums "go.temporal.io/api/enums/v1"
|
|
failure "go.temporal.io/api/failure/v1"
|
|
history "go.temporal.io/api/history/v1"
|
|
taskqueue "go.temporal.io/api/taskqueue/v1"
|
|
update "go.temporal.io/api/update/v1"
|
|
workflow "go.temporal.io/api/workflow/v1"
|
|
workflowservice "go.temporal.io/api/workflowservice/v1"
|
|
clock "go.temporal.io/server/api/clock/v1"
|
|
enums0 "go.temporal.io/server/api/enums/v1"
|
|
history0 "go.temporal.io/server/api/history/v1"
|
|
historyservice "go.temporal.io/server/api/historyservice/v1"
|
|
persistence "go.temporal.io/server/api/persistence/v1"
|
|
taskqueue0 "go.temporal.io/server/api/taskqueue/v1"
|
|
workflow0 "go.temporal.io/server/api/workflow/v1"
|
|
chasm "go.temporal.io/server/chasm"
|
|
workflow1 "go.temporal.io/server/chasm/lib/workflow"
|
|
definition "go.temporal.io/server/common/definition"
|
|
namespace "go.temporal.io/server/common/namespace"
|
|
persistence0 "go.temporal.io/server/common/persistence"
|
|
worker_versioning "go.temporal.io/server/common/worker_versioning"
|
|
historybuilder "go.temporal.io/server/service/history/historybuilder"
|
|
hsm "go.temporal.io/server/service/history/hsm"
|
|
tasks "go.temporal.io/server/service/history/tasks"
|
|
update0 "go.temporal.io/server/service/history/workflow/update"
|
|
gomock "go.uber.org/mock/gomock"
|
|
durationpb "google.golang.org/protobuf/types/known/durationpb"
|
|
timestamppb "google.golang.org/protobuf/types/known/timestamppb"
|
|
)
|
|
|
|
// MockMutableState is a mock of MutableState interface.
|
|
type MockMutableState struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockMutableStateMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockMutableStateMockRecorder is the mock recorder for MockMutableState.
|
|
type MockMutableStateMockRecorder struct {
|
|
mock *MockMutableState
|
|
}
|
|
|
|
// NewMockMutableState creates a new mock instance.
|
|
func NewMockMutableState(ctrl *gomock.Controller) *MockMutableState {
|
|
mock := &MockMutableState{ctrl: ctrl}
|
|
mock.recorder = &MockMutableStateMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockMutableState) EXPECT() *MockMutableStateMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// AddActivityTaskCancelRequestedEvent mocks base method.
|
|
func (m *MockMutableState) AddActivityTaskCancelRequestedEvent(arg0, arg1 int64, arg2 string) (*history.HistoryEvent, *persistence.ActivityInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddActivityTaskCancelRequestedEvent", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(*persistence.ActivityInfo)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// AddActivityTaskCancelRequestedEvent indicates an expected call of AddActivityTaskCancelRequestedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddActivityTaskCancelRequestedEvent(arg0, arg1, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddActivityTaskCancelRequestedEvent", reflect.TypeOf((*MockMutableState)(nil).AddActivityTaskCancelRequestedEvent), arg0, arg1, arg2)
|
|
}
|
|
|
|
// AddActivityTaskCanceledEvent mocks base method.
|
|
func (m *MockMutableState) AddActivityTaskCanceledEvent(arg0, arg1, arg2 int64, arg3 *common.Payloads, arg4 string) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddActivityTaskCanceledEvent", arg0, arg1, arg2, arg3, arg4)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddActivityTaskCanceledEvent indicates an expected call of AddActivityTaskCanceledEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddActivityTaskCanceledEvent(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddActivityTaskCanceledEvent", reflect.TypeOf((*MockMutableState)(nil).AddActivityTaskCanceledEvent), arg0, arg1, arg2, arg3, arg4)
|
|
}
|
|
|
|
// AddActivityTaskCompletedEvent mocks base method.
|
|
func (m *MockMutableState) AddActivityTaskCompletedEvent(arg0, arg1 int64, arg2 *workflowservice.RespondActivityTaskCompletedRequest) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddActivityTaskCompletedEvent", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddActivityTaskCompletedEvent indicates an expected call of AddActivityTaskCompletedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddActivityTaskCompletedEvent(arg0, arg1, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddActivityTaskCompletedEvent", reflect.TypeOf((*MockMutableState)(nil).AddActivityTaskCompletedEvent), arg0, arg1, arg2)
|
|
}
|
|
|
|
// AddActivityTaskFailedEvent mocks base method.
|
|
func (m *MockMutableState) AddActivityTaskFailedEvent(arg0, arg1 int64, arg2 *failure.Failure, arg3 enums.RetryState, arg4 string, arg5 *common.WorkerVersionStamp) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddActivityTaskFailedEvent", arg0, arg1, arg2, arg3, arg4, arg5)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddActivityTaskFailedEvent indicates an expected call of AddActivityTaskFailedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddActivityTaskFailedEvent(arg0, arg1, arg2, arg3, arg4, arg5 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddActivityTaskFailedEvent", reflect.TypeOf((*MockMutableState)(nil).AddActivityTaskFailedEvent), arg0, arg1, arg2, arg3, arg4, arg5)
|
|
}
|
|
|
|
// AddActivityTaskScheduledEvent mocks base method.
|
|
func (m *MockMutableState) AddActivityTaskScheduledEvent(arg0 int64, arg1 *command.ScheduleActivityTaskCommandAttributes, arg2 bool) (*history.HistoryEvent, *persistence.ActivityInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddActivityTaskScheduledEvent", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(*persistence.ActivityInfo)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// AddActivityTaskScheduledEvent indicates an expected call of AddActivityTaskScheduledEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddActivityTaskScheduledEvent(arg0, arg1, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddActivityTaskScheduledEvent", reflect.TypeOf((*MockMutableState)(nil).AddActivityTaskScheduledEvent), arg0, arg1, arg2)
|
|
}
|
|
|
|
// AddActivityTaskStartedEvent mocks base method.
|
|
func (m *MockMutableState) AddActivityTaskStartedEvent(arg0 *persistence.ActivityInfo, arg1 int64, arg2, arg3 string, arg4 *common.WorkerVersionStamp, arg5 *deployment.Deployment, arg6 *taskqueue0.BuildIdRedirectInfo) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddActivityTaskStartedEvent", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddActivityTaskStartedEvent indicates an expected call of AddActivityTaskStartedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddActivityTaskStartedEvent(arg0, arg1, arg2, arg3, arg4, arg5, arg6 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddActivityTaskStartedEvent", reflect.TypeOf((*MockMutableState)(nil).AddActivityTaskStartedEvent), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
|
|
}
|
|
|
|
// AddActivityTaskTimedOutEvent mocks base method.
|
|
func (m *MockMutableState) AddActivityTaskTimedOutEvent(arg0, arg1 int64, arg2 *failure.Failure, arg3 enums.RetryState) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddActivityTaskTimedOutEvent", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddActivityTaskTimedOutEvent indicates an expected call of AddActivityTaskTimedOutEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddActivityTaskTimedOutEvent(arg0, arg1, arg2, arg3 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddActivityTaskTimedOutEvent", reflect.TypeOf((*MockMutableState)(nil).AddActivityTaskTimedOutEvent), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// AddChildWorkflowExecutionCanceledEvent mocks base method.
|
|
func (m *MockMutableState) AddChildWorkflowExecutionCanceledEvent(arg0 int64, arg1 *common.WorkflowExecution, arg2 *history.WorkflowExecutionCanceledEventAttributes) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddChildWorkflowExecutionCanceledEvent", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddChildWorkflowExecutionCanceledEvent indicates an expected call of AddChildWorkflowExecutionCanceledEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddChildWorkflowExecutionCanceledEvent(arg0, arg1, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddChildWorkflowExecutionCanceledEvent", reflect.TypeOf((*MockMutableState)(nil).AddChildWorkflowExecutionCanceledEvent), arg0, arg1, arg2)
|
|
}
|
|
|
|
// AddChildWorkflowExecutionCompletedEvent mocks base method.
|
|
func (m *MockMutableState) AddChildWorkflowExecutionCompletedEvent(arg0 int64, arg1 *common.WorkflowExecution, arg2 *history.WorkflowExecutionCompletedEventAttributes) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddChildWorkflowExecutionCompletedEvent", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddChildWorkflowExecutionCompletedEvent indicates an expected call of AddChildWorkflowExecutionCompletedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddChildWorkflowExecutionCompletedEvent(arg0, arg1, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddChildWorkflowExecutionCompletedEvent", reflect.TypeOf((*MockMutableState)(nil).AddChildWorkflowExecutionCompletedEvent), arg0, arg1, arg2)
|
|
}
|
|
|
|
// AddChildWorkflowExecutionFailedEvent mocks base method.
|
|
func (m *MockMutableState) AddChildWorkflowExecutionFailedEvent(arg0 int64, arg1 *common.WorkflowExecution, arg2 *history.WorkflowExecutionFailedEventAttributes) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddChildWorkflowExecutionFailedEvent", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddChildWorkflowExecutionFailedEvent indicates an expected call of AddChildWorkflowExecutionFailedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddChildWorkflowExecutionFailedEvent(arg0, arg1, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddChildWorkflowExecutionFailedEvent", reflect.TypeOf((*MockMutableState)(nil).AddChildWorkflowExecutionFailedEvent), arg0, arg1, arg2)
|
|
}
|
|
|
|
// AddChildWorkflowExecutionStartedEvent mocks base method.
|
|
func (m *MockMutableState) AddChildWorkflowExecutionStartedEvent(arg0 *common.WorkflowExecution, arg1 *common.WorkflowType, arg2 int64, arg3 *common.Header, arg4 *clock.VectorClock) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddChildWorkflowExecutionStartedEvent", arg0, arg1, arg2, arg3, arg4)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddChildWorkflowExecutionStartedEvent indicates an expected call of AddChildWorkflowExecutionStartedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddChildWorkflowExecutionStartedEvent(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddChildWorkflowExecutionStartedEvent", reflect.TypeOf((*MockMutableState)(nil).AddChildWorkflowExecutionStartedEvent), arg0, arg1, arg2, arg3, arg4)
|
|
}
|
|
|
|
// AddChildWorkflowExecutionTerminatedEvent mocks base method.
|
|
func (m *MockMutableState) AddChildWorkflowExecutionTerminatedEvent(arg0 int64, arg1 *common.WorkflowExecution) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddChildWorkflowExecutionTerminatedEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddChildWorkflowExecutionTerminatedEvent indicates an expected call of AddChildWorkflowExecutionTerminatedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddChildWorkflowExecutionTerminatedEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddChildWorkflowExecutionTerminatedEvent", reflect.TypeOf((*MockMutableState)(nil).AddChildWorkflowExecutionTerminatedEvent), arg0, arg1)
|
|
}
|
|
|
|
// AddChildWorkflowExecutionTimedOutEvent mocks base method.
|
|
func (m *MockMutableState) AddChildWorkflowExecutionTimedOutEvent(arg0 int64, arg1 *common.WorkflowExecution, arg2 *history.WorkflowExecutionTimedOutEventAttributes) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddChildWorkflowExecutionTimedOutEvent", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddChildWorkflowExecutionTimedOutEvent indicates an expected call of AddChildWorkflowExecutionTimedOutEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddChildWorkflowExecutionTimedOutEvent(arg0, arg1, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddChildWorkflowExecutionTimedOutEvent", reflect.TypeOf((*MockMutableState)(nil).AddChildWorkflowExecutionTimedOutEvent), arg0, arg1, arg2)
|
|
}
|
|
|
|
// AddCompletedWorkflowEvent mocks base method.
|
|
func (m *MockMutableState) AddCompletedWorkflowEvent(arg0 int64, arg1 *command.CompleteWorkflowExecutionCommandAttributes, arg2 string) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddCompletedWorkflowEvent", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddCompletedWorkflowEvent indicates an expected call of AddCompletedWorkflowEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddCompletedWorkflowEvent(arg0, arg1, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCompletedWorkflowEvent", reflect.TypeOf((*MockMutableState)(nil).AddCompletedWorkflowEvent), arg0, arg1, arg2)
|
|
}
|
|
|
|
// AddContinueAsNewEvent mocks base method.
|
|
func (m *MockMutableState) AddContinueAsNewEvent(arg0 context.Context, arg1, arg2 int64, arg3 namespace.Name, arg4 *command.ContinueAsNewWorkflowExecutionCommandAttributes, arg5 worker_versioning.IsWFTaskQueueInVersionDetector) (*history.HistoryEvent, MutableState, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddContinueAsNewEvent", arg0, arg1, arg2, arg3, arg4, arg5)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(MutableState)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// AddContinueAsNewEvent indicates an expected call of AddContinueAsNewEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddContinueAsNewEvent(arg0, arg1, arg2, arg3, arg4, arg5 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContinueAsNewEvent", reflect.TypeOf((*MockMutableState)(nil).AddContinueAsNewEvent), arg0, arg1, arg2, arg3, arg4, arg5)
|
|
}
|
|
|
|
// AddExternalPayloadCount mocks base method.
|
|
func (m *MockMutableState) AddExternalPayloadCount(count int64) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "AddExternalPayloadCount", count)
|
|
}
|
|
|
|
// AddExternalPayloadCount indicates an expected call of AddExternalPayloadCount.
|
|
func (mr *MockMutableStateMockRecorder) AddExternalPayloadCount(count any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddExternalPayloadCount", reflect.TypeOf((*MockMutableState)(nil).AddExternalPayloadCount), count)
|
|
}
|
|
|
|
// AddExternalPayloadSize mocks base method.
|
|
func (m *MockMutableState) AddExternalPayloadSize(size int64) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "AddExternalPayloadSize", size)
|
|
}
|
|
|
|
// AddExternalPayloadSize indicates an expected call of AddExternalPayloadSize.
|
|
func (mr *MockMutableStateMockRecorder) AddExternalPayloadSize(size any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddExternalPayloadSize", reflect.TypeOf((*MockMutableState)(nil).AddExternalPayloadSize), size)
|
|
}
|
|
|
|
// AddExternalWorkflowExecutionCancelRequested mocks base method.
|
|
func (m *MockMutableState) AddExternalWorkflowExecutionCancelRequested(arg0 int64, arg1 namespace.Name, arg2 namespace.ID, arg3, arg4 string) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddExternalWorkflowExecutionCancelRequested", arg0, arg1, arg2, arg3, arg4)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddExternalWorkflowExecutionCancelRequested indicates an expected call of AddExternalWorkflowExecutionCancelRequested.
|
|
func (mr *MockMutableStateMockRecorder) AddExternalWorkflowExecutionCancelRequested(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddExternalWorkflowExecutionCancelRequested", reflect.TypeOf((*MockMutableState)(nil).AddExternalWorkflowExecutionCancelRequested), arg0, arg1, arg2, arg3, arg4)
|
|
}
|
|
|
|
// AddExternalWorkflowExecutionSignaled mocks base method.
|
|
func (m *MockMutableState) AddExternalWorkflowExecutionSignaled(arg0 int64, arg1 namespace.Name, arg2 namespace.ID, arg3, arg4, arg5 string) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddExternalWorkflowExecutionSignaled", arg0, arg1, arg2, arg3, arg4, arg5)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddExternalWorkflowExecutionSignaled indicates an expected call of AddExternalWorkflowExecutionSignaled.
|
|
func (mr *MockMutableStateMockRecorder) AddExternalWorkflowExecutionSignaled(arg0, arg1, arg2, arg3, arg4, arg5 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddExternalWorkflowExecutionSignaled", reflect.TypeOf((*MockMutableState)(nil).AddExternalWorkflowExecutionSignaled), arg0, arg1, arg2, arg3, arg4, arg5)
|
|
}
|
|
|
|
// AddFailWorkflowEvent mocks base method.
|
|
func (m *MockMutableState) AddFailWorkflowEvent(arg0 int64, arg1 enums.RetryState, arg2 *command.FailWorkflowExecutionCommandAttributes, arg3 string) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddFailWorkflowEvent", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddFailWorkflowEvent indicates an expected call of AddFailWorkflowEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddFailWorkflowEvent(arg0, arg1, arg2, arg3 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddFailWorkflowEvent", reflect.TypeOf((*MockMutableState)(nil).AddFailWorkflowEvent), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// AddFirstWorkflowTaskScheduled mocks base method.
|
|
func (m *MockMutableState) AddFirstWorkflowTaskScheduled(parentClock *clock.VectorClock, event *history.HistoryEvent, bypassTaskGeneration bool) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddFirstWorkflowTaskScheduled", parentClock, event, bypassTaskGeneration)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddFirstWorkflowTaskScheduled indicates an expected call of AddFirstWorkflowTaskScheduled.
|
|
func (mr *MockMutableStateMockRecorder) AddFirstWorkflowTaskScheduled(parentClock, event, bypassTaskGeneration any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddFirstWorkflowTaskScheduled", reflect.TypeOf((*MockMutableState)(nil).AddFirstWorkflowTaskScheduled), parentClock, event, bypassTaskGeneration)
|
|
}
|
|
|
|
// AddHistoryEvent mocks base method.
|
|
func (m *MockMutableState) AddHistoryEvent(t enums.EventType, setAttributes func(*history.HistoryEvent)) *history.HistoryEvent {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddHistoryEvent", t, setAttributes)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
return ret0
|
|
}
|
|
|
|
// AddHistoryEvent indicates an expected call of AddHistoryEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddHistoryEvent(t, setAttributes any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHistoryEvent", reflect.TypeOf((*MockMutableState)(nil).AddHistoryEvent), t, setAttributes)
|
|
}
|
|
|
|
// AddHistorySize mocks base method.
|
|
func (m *MockMutableState) AddHistorySize(size int64) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "AddHistorySize", size)
|
|
}
|
|
|
|
// AddHistorySize indicates an expected call of AddHistorySize.
|
|
func (mr *MockMutableStateMockRecorder) AddHistorySize(size any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHistorySize", reflect.TypeOf((*MockMutableState)(nil).AddHistorySize), size)
|
|
}
|
|
|
|
// AddReapplyCandidateEvent mocks base method.
|
|
func (m *MockMutableState) AddReapplyCandidateEvent(event *history.HistoryEvent) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "AddReapplyCandidateEvent", event)
|
|
}
|
|
|
|
// AddReapplyCandidateEvent indicates an expected call of AddReapplyCandidateEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddReapplyCandidateEvent(event any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddReapplyCandidateEvent", reflect.TypeOf((*MockMutableState)(nil).AddReapplyCandidateEvent), event)
|
|
}
|
|
|
|
// AddRecordMarkerEvent mocks base method.
|
|
func (m *MockMutableState) AddRecordMarkerEvent(arg0 int64, arg1 *command.RecordMarkerCommandAttributes) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddRecordMarkerEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddRecordMarkerEvent indicates an expected call of AddRecordMarkerEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddRecordMarkerEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRecordMarkerEvent", reflect.TypeOf((*MockMutableState)(nil).AddRecordMarkerEvent), arg0, arg1)
|
|
}
|
|
|
|
// AddRequestCancelExternalWorkflowExecutionFailedEvent mocks base method.
|
|
func (m *MockMutableState) AddRequestCancelExternalWorkflowExecutionFailedEvent(arg0 int64, arg1 namespace.Name, arg2 namespace.ID, arg3, arg4 string, arg5 enums.CancelExternalWorkflowExecutionFailedCause) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddRequestCancelExternalWorkflowExecutionFailedEvent", arg0, arg1, arg2, arg3, arg4, arg5)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddRequestCancelExternalWorkflowExecutionFailedEvent indicates an expected call of AddRequestCancelExternalWorkflowExecutionFailedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddRequestCancelExternalWorkflowExecutionFailedEvent(arg0, arg1, arg2, arg3, arg4, arg5 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRequestCancelExternalWorkflowExecutionFailedEvent", reflect.TypeOf((*MockMutableState)(nil).AddRequestCancelExternalWorkflowExecutionFailedEvent), arg0, arg1, arg2, arg3, arg4, arg5)
|
|
}
|
|
|
|
// AddRequestCancelExternalWorkflowExecutionInitiatedEvent mocks base method.
|
|
func (m *MockMutableState) AddRequestCancelExternalWorkflowExecutionInitiatedEvent(arg0 int64, arg1 string, arg2 *command.RequestCancelExternalWorkflowExecutionCommandAttributes, arg3 namespace.ID) (*history.HistoryEvent, *persistence.RequestCancelInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddRequestCancelExternalWorkflowExecutionInitiatedEvent", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(*persistence.RequestCancelInfo)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// AddRequestCancelExternalWorkflowExecutionInitiatedEvent indicates an expected call of AddRequestCancelExternalWorkflowExecutionInitiatedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddRequestCancelExternalWorkflowExecutionInitiatedEvent(arg0, arg1, arg2, arg3 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRequestCancelExternalWorkflowExecutionInitiatedEvent", reflect.TypeOf((*MockMutableState)(nil).AddRequestCancelExternalWorkflowExecutionInitiatedEvent), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// AddSignalExternalWorkflowExecutionFailedEvent mocks base method.
|
|
func (m *MockMutableState) AddSignalExternalWorkflowExecutionFailedEvent(arg0 int64, arg1 namespace.Name, arg2 namespace.ID, arg3, arg4, arg5 string, arg6 enums.SignalExternalWorkflowExecutionFailedCause) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddSignalExternalWorkflowExecutionFailedEvent", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddSignalExternalWorkflowExecutionFailedEvent indicates an expected call of AddSignalExternalWorkflowExecutionFailedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddSignalExternalWorkflowExecutionFailedEvent(arg0, arg1, arg2, arg3, arg4, arg5, arg6 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSignalExternalWorkflowExecutionFailedEvent", reflect.TypeOf((*MockMutableState)(nil).AddSignalExternalWorkflowExecutionFailedEvent), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
|
|
}
|
|
|
|
// AddSignalExternalWorkflowExecutionInitiatedEvent mocks base method.
|
|
func (m *MockMutableState) AddSignalExternalWorkflowExecutionInitiatedEvent(arg0 int64, arg1 string, arg2 *command.SignalExternalWorkflowExecutionCommandAttributes, arg3 namespace.ID) (*history.HistoryEvent, *persistence.SignalInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddSignalExternalWorkflowExecutionInitiatedEvent", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(*persistence.SignalInfo)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// AddSignalExternalWorkflowExecutionInitiatedEvent indicates an expected call of AddSignalExternalWorkflowExecutionInitiatedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddSignalExternalWorkflowExecutionInitiatedEvent(arg0, arg1, arg2, arg3 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSignalExternalWorkflowExecutionInitiatedEvent", reflect.TypeOf((*MockMutableState)(nil).AddSignalExternalWorkflowExecutionInitiatedEvent), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// AddSignalRequested mocks base method.
|
|
func (m *MockMutableState) AddSignalRequested(requestID string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "AddSignalRequested", requestID)
|
|
}
|
|
|
|
// AddSignalRequested indicates an expected call of AddSignalRequested.
|
|
func (mr *MockMutableStateMockRecorder) AddSignalRequested(requestID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSignalRequested", reflect.TypeOf((*MockMutableState)(nil).AddSignalRequested), requestID)
|
|
}
|
|
|
|
// AddStartChildWorkflowExecutionFailedEvent mocks base method.
|
|
func (m *MockMutableState) AddStartChildWorkflowExecutionFailedEvent(arg0 int64, arg1 enums.StartChildWorkflowExecutionFailedCause, arg2 *history.StartChildWorkflowExecutionInitiatedEventAttributes) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddStartChildWorkflowExecutionFailedEvent", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddStartChildWorkflowExecutionFailedEvent indicates an expected call of AddStartChildWorkflowExecutionFailedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddStartChildWorkflowExecutionFailedEvent(arg0, arg1, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddStartChildWorkflowExecutionFailedEvent", reflect.TypeOf((*MockMutableState)(nil).AddStartChildWorkflowExecutionFailedEvent), arg0, arg1, arg2)
|
|
}
|
|
|
|
// AddStartChildWorkflowExecutionInitiatedEvent mocks base method.
|
|
func (m *MockMutableState) AddStartChildWorkflowExecutionInitiatedEvent(arg0 int64, arg1 *command.StartChildWorkflowExecutionCommandAttributes, arg2 namespace.ID) (*history.HistoryEvent, *persistence.ChildExecutionInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddStartChildWorkflowExecutionInitiatedEvent", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(*persistence.ChildExecutionInfo)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// AddStartChildWorkflowExecutionInitiatedEvent indicates an expected call of AddStartChildWorkflowExecutionInitiatedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddStartChildWorkflowExecutionInitiatedEvent(arg0, arg1, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddStartChildWorkflowExecutionInitiatedEvent", reflect.TypeOf((*MockMutableState)(nil).AddStartChildWorkflowExecutionInitiatedEvent), arg0, arg1, arg2)
|
|
}
|
|
|
|
// AddTasks mocks base method.
|
|
func (m *MockMutableState) AddTasks(arg0 ...tasks.Task) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{}
|
|
for _, a := range arg0 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
m.ctrl.Call(m, "AddTasks", varargs...)
|
|
}
|
|
|
|
// AddTasks indicates an expected call of AddTasks.
|
|
func (mr *MockMutableStateMockRecorder) AddTasks(arg0 ...any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTasks", reflect.TypeOf((*MockMutableState)(nil).AddTasks), arg0...)
|
|
}
|
|
|
|
// AddTimeoutWorkflowEvent mocks base method.
|
|
func (m *MockMutableState) AddTimeoutWorkflowEvent(arg0 int64, arg1 enums.RetryState, arg2 string) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddTimeoutWorkflowEvent", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddTimeoutWorkflowEvent indicates an expected call of AddTimeoutWorkflowEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddTimeoutWorkflowEvent(arg0, arg1, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTimeoutWorkflowEvent", reflect.TypeOf((*MockMutableState)(nil).AddTimeoutWorkflowEvent), arg0, arg1, arg2)
|
|
}
|
|
|
|
// AddTimerCanceledEvent mocks base method.
|
|
func (m *MockMutableState) AddTimerCanceledEvent(arg0 int64, arg1 *command.CancelTimerCommandAttributes, arg2 string) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddTimerCanceledEvent", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddTimerCanceledEvent indicates an expected call of AddTimerCanceledEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddTimerCanceledEvent(arg0, arg1, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTimerCanceledEvent", reflect.TypeOf((*MockMutableState)(nil).AddTimerCanceledEvent), arg0, arg1, arg2)
|
|
}
|
|
|
|
// AddTimerFiredEvent mocks base method.
|
|
func (m *MockMutableState) AddTimerFiredEvent(arg0 string) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddTimerFiredEvent", arg0)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddTimerFiredEvent indicates an expected call of AddTimerFiredEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddTimerFiredEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTimerFiredEvent", reflect.TypeOf((*MockMutableState)(nil).AddTimerFiredEvent), arg0)
|
|
}
|
|
|
|
// AddTimerStartedEvent mocks base method.
|
|
func (m *MockMutableState) AddTimerStartedEvent(arg0 int64, arg1 *command.StartTimerCommandAttributes) (*history.HistoryEvent, *persistence.TimerInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddTimerStartedEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(*persistence.TimerInfo)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// AddTimerStartedEvent indicates an expected call of AddTimerStartedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddTimerStartedEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTimerStartedEvent", reflect.TypeOf((*MockMutableState)(nil).AddTimerStartedEvent), arg0, arg1)
|
|
}
|
|
|
|
// AddUpsertWorkflowSearchAttributesEvent mocks base method.
|
|
func (m *MockMutableState) AddUpsertWorkflowSearchAttributesEvent(arg0 int64, arg1 *command.UpsertWorkflowSearchAttributesCommandAttributes) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddUpsertWorkflowSearchAttributesEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddUpsertWorkflowSearchAttributesEvent indicates an expected call of AddUpsertWorkflowSearchAttributesEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddUpsertWorkflowSearchAttributesEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddUpsertWorkflowSearchAttributesEvent", reflect.TypeOf((*MockMutableState)(nil).AddUpsertWorkflowSearchAttributesEvent), arg0, arg1)
|
|
}
|
|
|
|
// AddWorkflowExecutionCancelRequestedEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowExecutionCancelRequestedEvent(arg0 *historyservice.RequestCancelWorkflowExecutionRequest) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowExecutionCancelRequestedEvent", arg0)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowExecutionCancelRequestedEvent indicates an expected call of AddWorkflowExecutionCancelRequestedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionCancelRequestedEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionCancelRequestedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionCancelRequestedEvent), arg0)
|
|
}
|
|
|
|
// AddWorkflowExecutionCanceledEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowExecutionCanceledEvent(arg0 int64, arg1 *command.CancelWorkflowExecutionCommandAttributes) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowExecutionCanceledEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowExecutionCanceledEvent indicates an expected call of AddWorkflowExecutionCanceledEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionCanceledEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionCanceledEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionCanceledEvent), arg0, arg1)
|
|
}
|
|
|
|
// AddWorkflowExecutionOptionsUpdatedEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowExecutionOptionsUpdatedEvent(versioningOverride *workflow.VersioningOverride, unsetVersioningOverride bool, attachRequestID string, attachCompletionCallbacks []*common.Callback, links []*common.Link, identity string, priority *common.Priority) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowExecutionOptionsUpdatedEvent", versioningOverride, unsetVersioningOverride, attachRequestID, attachCompletionCallbacks, links, identity, priority)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowExecutionOptionsUpdatedEvent indicates an expected call of AddWorkflowExecutionOptionsUpdatedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionOptionsUpdatedEvent(versioningOverride, unsetVersioningOverride, attachRequestID, attachCompletionCallbacks, links, identity, priority any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionOptionsUpdatedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionOptionsUpdatedEvent), versioningOverride, unsetVersioningOverride, attachRequestID, attachCompletionCallbacks, links, identity, priority)
|
|
}
|
|
|
|
// AddWorkflowExecutionPausedEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowExecutionPausedEvent(identity, reason, requestID string) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowExecutionPausedEvent", identity, reason, requestID)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowExecutionPausedEvent indicates an expected call of AddWorkflowExecutionPausedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionPausedEvent(identity, reason, requestID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionPausedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionPausedEvent), identity, reason, requestID)
|
|
}
|
|
|
|
// AddWorkflowExecutionSignaled mocks base method.
|
|
func (m *MockMutableState) AddWorkflowExecutionSignaled(signalName string, input *common.Payloads, identity string, header *common.Header, links []*common.Link) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowExecutionSignaled", signalName, input, identity, header, links)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowExecutionSignaled indicates an expected call of AddWorkflowExecutionSignaled.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionSignaled(signalName, input, identity, header, links any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionSignaled", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionSignaled), signalName, input, identity, header, links)
|
|
}
|
|
|
|
// AddWorkflowExecutionSignaledEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowExecutionSignaledEvent(signalName string, input *common.Payloads, identity string, header *common.Header, externalWorkflowExecution *common.WorkflowExecution, links []*common.Link) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowExecutionSignaledEvent", signalName, input, identity, header, externalWorkflowExecution, links)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowExecutionSignaledEvent indicates an expected call of AddWorkflowExecutionSignaledEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionSignaledEvent(signalName, input, identity, header, externalWorkflowExecution, links any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionSignaledEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionSignaledEvent), signalName, input, identity, header, externalWorkflowExecution, links)
|
|
}
|
|
|
|
// AddWorkflowExecutionStartedEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowExecutionStartedEvent(arg0 *common.WorkflowExecution, arg1 *historyservice.StartWorkflowExecutionRequest) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowExecutionStartedEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowExecutionStartedEvent indicates an expected call of AddWorkflowExecutionStartedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionStartedEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionStartedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionStartedEvent), arg0, arg1)
|
|
}
|
|
|
|
// AddWorkflowExecutionStartedEventWithOptions mocks base method.
|
|
func (m *MockMutableState) AddWorkflowExecutionStartedEventWithOptions(arg0 *common.WorkflowExecution, arg1 *historyservice.StartWorkflowExecutionRequest, arg2 *workflow.ResetPoints, arg3, arg4 string) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowExecutionStartedEventWithOptions", arg0, arg1, arg2, arg3, arg4)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowExecutionStartedEventWithOptions indicates an expected call of AddWorkflowExecutionStartedEventWithOptions.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionStartedEventWithOptions(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionStartedEventWithOptions", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionStartedEventWithOptions), arg0, arg1, arg2, arg3, arg4)
|
|
}
|
|
|
|
// AddWorkflowExecutionTerminatedEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowExecutionTerminatedEvent(firstEventID int64, reason string, details *common.Payloads, identity string, deleteAfterTerminate bool, links []*common.Link) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowExecutionTerminatedEvent", firstEventID, reason, details, identity, deleteAfterTerminate, links)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowExecutionTerminatedEvent indicates an expected call of AddWorkflowExecutionTerminatedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionTerminatedEvent(firstEventID, reason, details, identity, deleteAfterTerminate, links any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionTerminatedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionTerminatedEvent), firstEventID, reason, details, identity, deleteAfterTerminate, links)
|
|
}
|
|
|
|
// AddWorkflowExecutionUnpausedEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowExecutionUnpausedEvent(identity, reason, requestID string) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowExecutionUnpausedEvent", identity, reason, requestID)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowExecutionUnpausedEvent indicates an expected call of AddWorkflowExecutionUnpausedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionUnpausedEvent(identity, reason, requestID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionUnpausedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionUnpausedEvent), identity, reason, requestID)
|
|
}
|
|
|
|
// AddWorkflowExecutionUpdateAcceptedEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowExecutionUpdateAcceptedEvent(protocolInstanceID, acceptedRequestMessageId string, acceptedRequestSequencingEventId int64, acceptedRequest *update.Request) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowExecutionUpdateAcceptedEvent", protocolInstanceID, acceptedRequestMessageId, acceptedRequestSequencingEventId, acceptedRequest)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowExecutionUpdateAcceptedEvent indicates an expected call of AddWorkflowExecutionUpdateAcceptedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionUpdateAcceptedEvent(protocolInstanceID, acceptedRequestMessageId, acceptedRequestSequencingEventId, acceptedRequest any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionUpdateAcceptedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionUpdateAcceptedEvent), protocolInstanceID, acceptedRequestMessageId, acceptedRequestSequencingEventId, acceptedRequest)
|
|
}
|
|
|
|
// AddWorkflowExecutionUpdateAdmittedEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowExecutionUpdateAdmittedEvent(request *update.Request, origin enums.UpdateAdmittedEventOrigin) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowExecutionUpdateAdmittedEvent", request, origin)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowExecutionUpdateAdmittedEvent indicates an expected call of AddWorkflowExecutionUpdateAdmittedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionUpdateAdmittedEvent(request, origin any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionUpdateAdmittedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionUpdateAdmittedEvent), request, origin)
|
|
}
|
|
|
|
// AddWorkflowExecutionUpdateCompletedEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowExecutionUpdateCompletedEvent(acceptedEventID int64, updResp *update.Response) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowExecutionUpdateCompletedEvent", acceptedEventID, updResp)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowExecutionUpdateCompletedEvent indicates an expected call of AddWorkflowExecutionUpdateCompletedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowExecutionUpdateCompletedEvent(acceptedEventID, updResp any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowExecutionUpdateCompletedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowExecutionUpdateCompletedEvent), acceptedEventID, updResp)
|
|
}
|
|
|
|
// AddWorkflowPropertiesModifiedEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowPropertiesModifiedEvent(arg0 int64, arg1 *command.ModifyWorkflowPropertiesCommandAttributes) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowPropertiesModifiedEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowPropertiesModifiedEvent indicates an expected call of AddWorkflowPropertiesModifiedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowPropertiesModifiedEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowPropertiesModifiedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowPropertiesModifiedEvent), arg0, arg1)
|
|
}
|
|
|
|
// AddWorkflowTaskCompletedEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowTaskCompletedEvent(arg0 *WorkflowTaskInfo, arg1 *workflowservice.RespondWorkflowTaskCompletedRequest, arg2 WorkflowTaskCompletionLimits) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowTaskCompletedEvent", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowTaskCompletedEvent indicates an expected call of AddWorkflowTaskCompletedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowTaskCompletedEvent(arg0, arg1, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowTaskCompletedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowTaskCompletedEvent), arg0, arg1, arg2)
|
|
}
|
|
|
|
// AddWorkflowTaskFailedEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowTaskFailedEvent(workflowTask *WorkflowTaskInfo, cause enums.WorkflowTaskFailedCause, arg2 *failure.Failure, identity string, versioningStamp *common.WorkerVersionStamp, binChecksum, baseRunID, newRunID string, forkEventVersion int64) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowTaskFailedEvent", workflowTask, cause, arg2, identity, versioningStamp, binChecksum, baseRunID, newRunID, forkEventVersion)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowTaskFailedEvent indicates an expected call of AddWorkflowTaskFailedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowTaskFailedEvent(workflowTask, cause, arg2, identity, versioningStamp, binChecksum, baseRunID, newRunID, forkEventVersion any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowTaskFailedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowTaskFailedEvent), workflowTask, cause, arg2, identity, versioningStamp, binChecksum, baseRunID, newRunID, forkEventVersion)
|
|
}
|
|
|
|
// AddWorkflowTaskScheduleToStartTimeoutEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowTaskScheduleToStartTimeoutEvent(workflowTask *WorkflowTaskInfo) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowTaskScheduleToStartTimeoutEvent", workflowTask)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowTaskScheduleToStartTimeoutEvent indicates an expected call of AddWorkflowTaskScheduleToStartTimeoutEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowTaskScheduleToStartTimeoutEvent(workflowTask any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowTaskScheduleToStartTimeoutEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowTaskScheduleToStartTimeoutEvent), workflowTask)
|
|
}
|
|
|
|
// AddWorkflowTaskScheduledEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowTaskScheduledEvent(bypassTaskGeneration bool, workflowTaskType enums0.WorkflowTaskType) (*WorkflowTaskInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowTaskScheduledEvent", bypassTaskGeneration, workflowTaskType)
|
|
ret0, _ := ret[0].(*WorkflowTaskInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowTaskScheduledEvent indicates an expected call of AddWorkflowTaskScheduledEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowTaskScheduledEvent(bypassTaskGeneration, workflowTaskType any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowTaskScheduledEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowTaskScheduledEvent), bypassTaskGeneration, workflowTaskType)
|
|
}
|
|
|
|
// AddWorkflowTaskScheduledEventAsHeartbeat mocks base method.
|
|
func (m *MockMutableState) AddWorkflowTaskScheduledEventAsHeartbeat(bypassTaskGeneration bool, originalScheduledTimestamp *timestamppb.Timestamp, workflowTaskType enums0.WorkflowTaskType) (*WorkflowTaskInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowTaskScheduledEventAsHeartbeat", bypassTaskGeneration, originalScheduledTimestamp, workflowTaskType)
|
|
ret0, _ := ret[0].(*WorkflowTaskInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowTaskScheduledEventAsHeartbeat indicates an expected call of AddWorkflowTaskScheduledEventAsHeartbeat.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowTaskScheduledEventAsHeartbeat(bypassTaskGeneration, originalScheduledTimestamp, workflowTaskType any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowTaskScheduledEventAsHeartbeat", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowTaskScheduledEventAsHeartbeat), bypassTaskGeneration, originalScheduledTimestamp, workflowTaskType)
|
|
}
|
|
|
|
// AddWorkflowTaskStartedEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowTaskStartedEvent(arg0 int64, arg1 string, arg2 *taskqueue.TaskQueue, arg3 string, arg4 *common.WorkerVersionStamp, arg5 *taskqueue0.BuildIdRedirectInfo, arg6 update0.Registry, arg7 bool, arg8 *deployment.WorkerDeploymentVersion) (*history.HistoryEvent, *WorkflowTaskInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowTaskStartedEvent", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(*WorkflowTaskInfo)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// AddWorkflowTaskStartedEvent indicates an expected call of AddWorkflowTaskStartedEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowTaskStartedEvent(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowTaskStartedEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowTaskStartedEvent), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
|
|
}
|
|
|
|
// AddWorkflowTaskTimedOutEvent mocks base method.
|
|
func (m *MockMutableState) AddWorkflowTaskTimedOutEvent(workflowTask *WorkflowTaskInfo) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkflowTaskTimedOutEvent", workflowTask)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkflowTaskTimedOutEvent indicates an expected call of AddWorkflowTaskTimedOutEvent.
|
|
func (mr *MockMutableStateMockRecorder) AddWorkflowTaskTimedOutEvent(workflowTask any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkflowTaskTimedOutEvent", reflect.TypeOf((*MockMutableState)(nil).AddWorkflowTaskTimedOutEvent), workflowTask)
|
|
}
|
|
|
|
// ApplyActivityTaskCancelRequestedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyActivityTaskCancelRequestedEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyActivityTaskCancelRequestedEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyActivityTaskCancelRequestedEvent indicates an expected call of ApplyActivityTaskCancelRequestedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyActivityTaskCancelRequestedEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyActivityTaskCancelRequestedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyActivityTaskCancelRequestedEvent), arg0)
|
|
}
|
|
|
|
// ApplyActivityTaskCanceledEvent mocks base method.
|
|
func (m *MockMutableState) ApplyActivityTaskCanceledEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyActivityTaskCanceledEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyActivityTaskCanceledEvent indicates an expected call of ApplyActivityTaskCanceledEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyActivityTaskCanceledEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyActivityTaskCanceledEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyActivityTaskCanceledEvent), arg0)
|
|
}
|
|
|
|
// ApplyActivityTaskCompletedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyActivityTaskCompletedEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyActivityTaskCompletedEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyActivityTaskCompletedEvent indicates an expected call of ApplyActivityTaskCompletedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyActivityTaskCompletedEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyActivityTaskCompletedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyActivityTaskCompletedEvent), arg0)
|
|
}
|
|
|
|
// ApplyActivityTaskFailedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyActivityTaskFailedEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyActivityTaskFailedEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyActivityTaskFailedEvent indicates an expected call of ApplyActivityTaskFailedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyActivityTaskFailedEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyActivityTaskFailedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyActivityTaskFailedEvent), arg0)
|
|
}
|
|
|
|
// ApplyActivityTaskScheduledEvent mocks base method.
|
|
func (m *MockMutableState) ApplyActivityTaskScheduledEvent(arg0 int64, arg1 *history.HistoryEvent) (*persistence.ActivityInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyActivityTaskScheduledEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(*persistence.ActivityInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ApplyActivityTaskScheduledEvent indicates an expected call of ApplyActivityTaskScheduledEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyActivityTaskScheduledEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyActivityTaskScheduledEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyActivityTaskScheduledEvent), arg0, arg1)
|
|
}
|
|
|
|
// ApplyActivityTaskStartedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyActivityTaskStartedEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyActivityTaskStartedEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyActivityTaskStartedEvent indicates an expected call of ApplyActivityTaskStartedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyActivityTaskStartedEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyActivityTaskStartedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyActivityTaskStartedEvent), arg0)
|
|
}
|
|
|
|
// ApplyActivityTaskTimedOutEvent mocks base method.
|
|
func (m *MockMutableState) ApplyActivityTaskTimedOutEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyActivityTaskTimedOutEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyActivityTaskTimedOutEvent indicates an expected call of ApplyActivityTaskTimedOutEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyActivityTaskTimedOutEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyActivityTaskTimedOutEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyActivityTaskTimedOutEvent), arg0)
|
|
}
|
|
|
|
// ApplyBuildIdRedirect mocks base method.
|
|
func (m *MockMutableState) ApplyBuildIdRedirect(startingTaskScheduledEventId int64, buildId string, redirectCounter int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyBuildIdRedirect", startingTaskScheduledEventId, buildId, redirectCounter)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyBuildIdRedirect indicates an expected call of ApplyBuildIdRedirect.
|
|
func (mr *MockMutableStateMockRecorder) ApplyBuildIdRedirect(startingTaskScheduledEventId, buildId, redirectCounter any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyBuildIdRedirect", reflect.TypeOf((*MockMutableState)(nil).ApplyBuildIdRedirect), startingTaskScheduledEventId, buildId, redirectCounter)
|
|
}
|
|
|
|
// ApplyChildWorkflowExecutionCanceledEvent mocks base method.
|
|
func (m *MockMutableState) ApplyChildWorkflowExecutionCanceledEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyChildWorkflowExecutionCanceledEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyChildWorkflowExecutionCanceledEvent indicates an expected call of ApplyChildWorkflowExecutionCanceledEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyChildWorkflowExecutionCanceledEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyChildWorkflowExecutionCanceledEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyChildWorkflowExecutionCanceledEvent), arg0)
|
|
}
|
|
|
|
// ApplyChildWorkflowExecutionCompletedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyChildWorkflowExecutionCompletedEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyChildWorkflowExecutionCompletedEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyChildWorkflowExecutionCompletedEvent indicates an expected call of ApplyChildWorkflowExecutionCompletedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyChildWorkflowExecutionCompletedEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyChildWorkflowExecutionCompletedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyChildWorkflowExecutionCompletedEvent), arg0)
|
|
}
|
|
|
|
// ApplyChildWorkflowExecutionFailedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyChildWorkflowExecutionFailedEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyChildWorkflowExecutionFailedEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyChildWorkflowExecutionFailedEvent indicates an expected call of ApplyChildWorkflowExecutionFailedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyChildWorkflowExecutionFailedEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyChildWorkflowExecutionFailedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyChildWorkflowExecutionFailedEvent), arg0)
|
|
}
|
|
|
|
// ApplyChildWorkflowExecutionStartedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyChildWorkflowExecutionStartedEvent(arg0 *history.HistoryEvent, arg1 *clock.VectorClock) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyChildWorkflowExecutionStartedEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyChildWorkflowExecutionStartedEvent indicates an expected call of ApplyChildWorkflowExecutionStartedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyChildWorkflowExecutionStartedEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyChildWorkflowExecutionStartedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyChildWorkflowExecutionStartedEvent), arg0, arg1)
|
|
}
|
|
|
|
// ApplyChildWorkflowExecutionTerminatedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyChildWorkflowExecutionTerminatedEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyChildWorkflowExecutionTerminatedEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyChildWorkflowExecutionTerminatedEvent indicates an expected call of ApplyChildWorkflowExecutionTerminatedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyChildWorkflowExecutionTerminatedEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyChildWorkflowExecutionTerminatedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyChildWorkflowExecutionTerminatedEvent), arg0)
|
|
}
|
|
|
|
// ApplyChildWorkflowExecutionTimedOutEvent mocks base method.
|
|
func (m *MockMutableState) ApplyChildWorkflowExecutionTimedOutEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyChildWorkflowExecutionTimedOutEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyChildWorkflowExecutionTimedOutEvent indicates an expected call of ApplyChildWorkflowExecutionTimedOutEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyChildWorkflowExecutionTimedOutEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyChildWorkflowExecutionTimedOutEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyChildWorkflowExecutionTimedOutEvent), arg0)
|
|
}
|
|
|
|
// ApplyExternalWorkflowExecutionCancelRequested mocks base method.
|
|
func (m *MockMutableState) ApplyExternalWorkflowExecutionCancelRequested(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyExternalWorkflowExecutionCancelRequested", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyExternalWorkflowExecutionCancelRequested indicates an expected call of ApplyExternalWorkflowExecutionCancelRequested.
|
|
func (mr *MockMutableStateMockRecorder) ApplyExternalWorkflowExecutionCancelRequested(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyExternalWorkflowExecutionCancelRequested", reflect.TypeOf((*MockMutableState)(nil).ApplyExternalWorkflowExecutionCancelRequested), arg0)
|
|
}
|
|
|
|
// ApplyExternalWorkflowExecutionSignaled mocks base method.
|
|
func (m *MockMutableState) ApplyExternalWorkflowExecutionSignaled(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyExternalWorkflowExecutionSignaled", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyExternalWorkflowExecutionSignaled indicates an expected call of ApplyExternalWorkflowExecutionSignaled.
|
|
func (mr *MockMutableStateMockRecorder) ApplyExternalWorkflowExecutionSignaled(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyExternalWorkflowExecutionSignaled", reflect.TypeOf((*MockMutableState)(nil).ApplyExternalWorkflowExecutionSignaled), arg0)
|
|
}
|
|
|
|
// ApplyMutation mocks base method.
|
|
func (m *MockMutableState) ApplyMutation(mutation *persistence.WorkflowMutableStateMutation) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyMutation", mutation)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyMutation indicates an expected call of ApplyMutation.
|
|
func (mr *MockMutableStateMockRecorder) ApplyMutation(mutation any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyMutation", reflect.TypeOf((*MockMutableState)(nil).ApplyMutation), mutation)
|
|
}
|
|
|
|
// ApplyRequestCancelExternalWorkflowExecutionFailedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyRequestCancelExternalWorkflowExecutionFailedEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyRequestCancelExternalWorkflowExecutionFailedEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyRequestCancelExternalWorkflowExecutionFailedEvent indicates an expected call of ApplyRequestCancelExternalWorkflowExecutionFailedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyRequestCancelExternalWorkflowExecutionFailedEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyRequestCancelExternalWorkflowExecutionFailedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyRequestCancelExternalWorkflowExecutionFailedEvent), arg0)
|
|
}
|
|
|
|
// ApplyRequestCancelExternalWorkflowExecutionInitiatedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyRequestCancelExternalWorkflowExecutionInitiatedEvent(arg0 int64, arg1 *history.HistoryEvent, arg2 string) (*persistence.RequestCancelInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyRequestCancelExternalWorkflowExecutionInitiatedEvent", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*persistence.RequestCancelInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ApplyRequestCancelExternalWorkflowExecutionInitiatedEvent indicates an expected call of ApplyRequestCancelExternalWorkflowExecutionInitiatedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyRequestCancelExternalWorkflowExecutionInitiatedEvent(arg0, arg1, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyRequestCancelExternalWorkflowExecutionInitiatedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyRequestCancelExternalWorkflowExecutionInitiatedEvent), arg0, arg1, arg2)
|
|
}
|
|
|
|
// ApplySignalExternalWorkflowExecutionFailedEvent mocks base method.
|
|
func (m *MockMutableState) ApplySignalExternalWorkflowExecutionFailedEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplySignalExternalWorkflowExecutionFailedEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplySignalExternalWorkflowExecutionFailedEvent indicates an expected call of ApplySignalExternalWorkflowExecutionFailedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplySignalExternalWorkflowExecutionFailedEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySignalExternalWorkflowExecutionFailedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplySignalExternalWorkflowExecutionFailedEvent), arg0)
|
|
}
|
|
|
|
// ApplySignalExternalWorkflowExecutionInitiatedEvent mocks base method.
|
|
func (m *MockMutableState) ApplySignalExternalWorkflowExecutionInitiatedEvent(arg0 int64, arg1 *history.HistoryEvent, arg2 string) (*persistence.SignalInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplySignalExternalWorkflowExecutionInitiatedEvent", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(*persistence.SignalInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ApplySignalExternalWorkflowExecutionInitiatedEvent indicates an expected call of ApplySignalExternalWorkflowExecutionInitiatedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplySignalExternalWorkflowExecutionInitiatedEvent(arg0, arg1, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySignalExternalWorkflowExecutionInitiatedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplySignalExternalWorkflowExecutionInitiatedEvent), arg0, arg1, arg2)
|
|
}
|
|
|
|
// ApplySnapshot mocks base method.
|
|
func (m *MockMutableState) ApplySnapshot(snapshot *persistence.WorkflowMutableState) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplySnapshot", snapshot)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplySnapshot indicates an expected call of ApplySnapshot.
|
|
func (mr *MockMutableStateMockRecorder) ApplySnapshot(snapshot any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySnapshot", reflect.TypeOf((*MockMutableState)(nil).ApplySnapshot), snapshot)
|
|
}
|
|
|
|
// ApplyStartChildWorkflowExecutionFailedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyStartChildWorkflowExecutionFailedEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyStartChildWorkflowExecutionFailedEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyStartChildWorkflowExecutionFailedEvent indicates an expected call of ApplyStartChildWorkflowExecutionFailedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyStartChildWorkflowExecutionFailedEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyStartChildWorkflowExecutionFailedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyStartChildWorkflowExecutionFailedEvent), arg0)
|
|
}
|
|
|
|
// ApplyStartChildWorkflowExecutionInitiatedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyStartChildWorkflowExecutionInitiatedEvent(arg0 int64, arg1 *history.HistoryEvent) (*persistence.ChildExecutionInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyStartChildWorkflowExecutionInitiatedEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(*persistence.ChildExecutionInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ApplyStartChildWorkflowExecutionInitiatedEvent indicates an expected call of ApplyStartChildWorkflowExecutionInitiatedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyStartChildWorkflowExecutionInitiatedEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyStartChildWorkflowExecutionInitiatedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyStartChildWorkflowExecutionInitiatedEvent), arg0, arg1)
|
|
}
|
|
|
|
// ApplyTimerCanceledEvent mocks base method.
|
|
func (m *MockMutableState) ApplyTimerCanceledEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyTimerCanceledEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyTimerCanceledEvent indicates an expected call of ApplyTimerCanceledEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyTimerCanceledEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyTimerCanceledEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyTimerCanceledEvent), arg0)
|
|
}
|
|
|
|
// ApplyTimerFiredEvent mocks base method.
|
|
func (m *MockMutableState) ApplyTimerFiredEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyTimerFiredEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyTimerFiredEvent indicates an expected call of ApplyTimerFiredEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyTimerFiredEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyTimerFiredEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyTimerFiredEvent), arg0)
|
|
}
|
|
|
|
// ApplyTimerStartedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyTimerStartedEvent(arg0 *history.HistoryEvent) (*persistence.TimerInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyTimerStartedEvent", arg0)
|
|
ret0, _ := ret[0].(*persistence.TimerInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ApplyTimerStartedEvent indicates an expected call of ApplyTimerStartedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyTimerStartedEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyTimerStartedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyTimerStartedEvent), arg0)
|
|
}
|
|
|
|
// ApplyTransientWorkflowTaskScheduled mocks base method.
|
|
func (m *MockMutableState) ApplyTransientWorkflowTaskScheduled() (*WorkflowTaskInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyTransientWorkflowTaskScheduled")
|
|
ret0, _ := ret[0].(*WorkflowTaskInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ApplyTransientWorkflowTaskScheduled indicates an expected call of ApplyTransientWorkflowTaskScheduled.
|
|
func (mr *MockMutableStateMockRecorder) ApplyTransientWorkflowTaskScheduled() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyTransientWorkflowTaskScheduled", reflect.TypeOf((*MockMutableState)(nil).ApplyTransientWorkflowTaskScheduled))
|
|
}
|
|
|
|
// ApplyUpsertWorkflowSearchAttributesEvent mocks base method.
|
|
func (m *MockMutableState) ApplyUpsertWorkflowSearchAttributesEvent(arg0 *history.HistoryEvent) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "ApplyUpsertWorkflowSearchAttributesEvent", arg0)
|
|
}
|
|
|
|
// ApplyUpsertWorkflowSearchAttributesEvent indicates an expected call of ApplyUpsertWorkflowSearchAttributesEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyUpsertWorkflowSearchAttributesEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyUpsertWorkflowSearchAttributesEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyUpsertWorkflowSearchAttributesEvent), arg0)
|
|
}
|
|
|
|
// ApplyWorkflowExecutionCancelRequestedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowExecutionCancelRequestedEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowExecutionCancelRequestedEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowExecutionCancelRequestedEvent indicates an expected call of ApplyWorkflowExecutionCancelRequestedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionCancelRequestedEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionCancelRequestedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionCancelRequestedEvent), arg0)
|
|
}
|
|
|
|
// ApplyWorkflowExecutionCanceledEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowExecutionCanceledEvent(arg0 int64, arg1 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowExecutionCanceledEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowExecutionCanceledEvent indicates an expected call of ApplyWorkflowExecutionCanceledEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionCanceledEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionCanceledEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionCanceledEvent), arg0, arg1)
|
|
}
|
|
|
|
// ApplyWorkflowExecutionCompletedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowExecutionCompletedEvent(arg0 int64, arg1 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowExecutionCompletedEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowExecutionCompletedEvent indicates an expected call of ApplyWorkflowExecutionCompletedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionCompletedEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionCompletedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionCompletedEvent), arg0, arg1)
|
|
}
|
|
|
|
// ApplyWorkflowExecutionContinuedAsNewEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowExecutionContinuedAsNewEvent(arg0 int64, arg1 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowExecutionContinuedAsNewEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowExecutionContinuedAsNewEvent indicates an expected call of ApplyWorkflowExecutionContinuedAsNewEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionContinuedAsNewEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionContinuedAsNewEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionContinuedAsNewEvent), arg0, arg1)
|
|
}
|
|
|
|
// ApplyWorkflowExecutionFailedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowExecutionFailedEvent(arg0 int64, arg1 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowExecutionFailedEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowExecutionFailedEvent indicates an expected call of ApplyWorkflowExecutionFailedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionFailedEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionFailedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionFailedEvent), arg0, arg1)
|
|
}
|
|
|
|
// ApplyWorkflowExecutionOptionsUpdatedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowExecutionOptionsUpdatedEvent(event *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowExecutionOptionsUpdatedEvent", event)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowExecutionOptionsUpdatedEvent indicates an expected call of ApplyWorkflowExecutionOptionsUpdatedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionOptionsUpdatedEvent(event any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionOptionsUpdatedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionOptionsUpdatedEvent), event)
|
|
}
|
|
|
|
// ApplyWorkflowExecutionPausedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowExecutionPausedEvent(event *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowExecutionPausedEvent", event)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowExecutionPausedEvent indicates an expected call of ApplyWorkflowExecutionPausedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionPausedEvent(event any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionPausedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionPausedEvent), event)
|
|
}
|
|
|
|
// ApplyWorkflowExecutionSignaled mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowExecutionSignaled(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowExecutionSignaled", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowExecutionSignaled indicates an expected call of ApplyWorkflowExecutionSignaled.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionSignaled(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionSignaled", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionSignaled), arg0)
|
|
}
|
|
|
|
// ApplyWorkflowExecutionStartedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowExecutionStartedEvent(arg0 *clock.VectorClock, arg1 *common.WorkflowExecution, arg2 string, arg3 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowExecutionStartedEvent", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowExecutionStartedEvent indicates an expected call of ApplyWorkflowExecutionStartedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionStartedEvent(arg0, arg1, arg2, arg3 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionStartedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionStartedEvent), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// ApplyWorkflowExecutionTerminatedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowExecutionTerminatedEvent(arg0 int64, arg1 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowExecutionTerminatedEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowExecutionTerminatedEvent indicates an expected call of ApplyWorkflowExecutionTerminatedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionTerminatedEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionTerminatedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionTerminatedEvent), arg0, arg1)
|
|
}
|
|
|
|
// ApplyWorkflowExecutionTimedoutEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowExecutionTimedoutEvent(arg0 int64, arg1 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowExecutionTimedoutEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowExecutionTimedoutEvent indicates an expected call of ApplyWorkflowExecutionTimedoutEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionTimedoutEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionTimedoutEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionTimedoutEvent), arg0, arg1)
|
|
}
|
|
|
|
// ApplyWorkflowExecutionUnpausedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowExecutionUnpausedEvent(event *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowExecutionUnpausedEvent", event)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowExecutionUnpausedEvent indicates an expected call of ApplyWorkflowExecutionUnpausedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionUnpausedEvent(event any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionUnpausedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionUnpausedEvent), event)
|
|
}
|
|
|
|
// ApplyWorkflowExecutionUpdateAcceptedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowExecutionUpdateAcceptedEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowExecutionUpdateAcceptedEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowExecutionUpdateAcceptedEvent indicates an expected call of ApplyWorkflowExecutionUpdateAcceptedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionUpdateAcceptedEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionUpdateAcceptedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionUpdateAcceptedEvent), arg0)
|
|
}
|
|
|
|
// ApplyWorkflowExecutionUpdateAdmittedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowExecutionUpdateAdmittedEvent(event *history.HistoryEvent, batchId int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowExecutionUpdateAdmittedEvent", event, batchId)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowExecutionUpdateAdmittedEvent indicates an expected call of ApplyWorkflowExecutionUpdateAdmittedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionUpdateAdmittedEvent(event, batchId any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionUpdateAdmittedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionUpdateAdmittedEvent), event, batchId)
|
|
}
|
|
|
|
// ApplyWorkflowExecutionUpdateCompletedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowExecutionUpdateCompletedEvent(event *history.HistoryEvent, batchID int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowExecutionUpdateCompletedEvent", event, batchID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowExecutionUpdateCompletedEvent indicates an expected call of ApplyWorkflowExecutionUpdateCompletedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowExecutionUpdateCompletedEvent(event, batchID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowExecutionUpdateCompletedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowExecutionUpdateCompletedEvent), event, batchID)
|
|
}
|
|
|
|
// ApplyWorkflowPropertiesModifiedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowPropertiesModifiedEvent(arg0 *history.HistoryEvent) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "ApplyWorkflowPropertiesModifiedEvent", arg0)
|
|
}
|
|
|
|
// ApplyWorkflowPropertiesModifiedEvent indicates an expected call of ApplyWorkflowPropertiesModifiedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowPropertiesModifiedEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowPropertiesModifiedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowPropertiesModifiedEvent), arg0)
|
|
}
|
|
|
|
// ApplyWorkflowTaskCompletedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowTaskCompletedEvent(arg0 *history.HistoryEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowTaskCompletedEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowTaskCompletedEvent indicates an expected call of ApplyWorkflowTaskCompletedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowTaskCompletedEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowTaskCompletedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowTaskCompletedEvent), arg0)
|
|
}
|
|
|
|
// ApplyWorkflowTaskFailedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowTaskFailedEvent() error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowTaskFailedEvent")
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowTaskFailedEvent indicates an expected call of ApplyWorkflowTaskFailedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowTaskFailedEvent() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowTaskFailedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowTaskFailedEvent))
|
|
}
|
|
|
|
// ApplyWorkflowTaskScheduledEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowTaskScheduledEvent(arg0, arg1 int64, arg2 *taskqueue.TaskQueue, arg3 *durationpb.Duration, arg4 int32, arg5, arg6 *timestamppb.Timestamp, arg7 enums0.WorkflowTaskType) (*WorkflowTaskInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowTaskScheduledEvent", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
|
|
ret0, _ := ret[0].(*WorkflowTaskInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ApplyWorkflowTaskScheduledEvent indicates an expected call of ApplyWorkflowTaskScheduledEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowTaskScheduledEvent(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowTaskScheduledEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowTaskScheduledEvent), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
|
|
}
|
|
|
|
// ApplyWorkflowTaskStartedEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowTaskStartedEvent(arg0 *WorkflowTaskInfo, arg1, arg2, arg3 int64, arg4 string, arg5 time.Time, arg6 bool, arg7 int64, arg8 *common.WorkerVersionStamp, arg9 int64, arg10 []enums.SuggestContinueAsNewReason, arg11 bool) (*WorkflowTaskInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowTaskStartedEvent", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
|
|
ret0, _ := ret[0].(*WorkflowTaskInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ApplyWorkflowTaskStartedEvent indicates an expected call of ApplyWorkflowTaskStartedEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowTaskStartedEvent(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowTaskStartedEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowTaskStartedEvent), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
|
|
}
|
|
|
|
// ApplyWorkflowTaskTimedOutEvent mocks base method.
|
|
func (m *MockMutableState) ApplyWorkflowTaskTimedOutEvent(arg0 enums.TimeoutType) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ApplyWorkflowTaskTimedOutEvent", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ApplyWorkflowTaskTimedOutEvent indicates an expected call of ApplyWorkflowTaskTimedOutEvent.
|
|
func (mr *MockMutableStateMockRecorder) ApplyWorkflowTaskTimedOutEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWorkflowTaskTimedOutEvent", reflect.TypeOf((*MockMutableState)(nil).ApplyWorkflowTaskTimedOutEvent), arg0)
|
|
}
|
|
|
|
// AttachRequestID mocks base method.
|
|
func (m *MockMutableState) AttachRequestID(requestID string, eventType enums.EventType, eventID int64) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "AttachRequestID", requestID, eventType, eventID)
|
|
}
|
|
|
|
// AttachRequestID indicates an expected call of AttachRequestID.
|
|
func (mr *MockMutableStateMockRecorder) AttachRequestID(requestID, eventType, eventID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachRequestID", reflect.TypeOf((*MockMutableState)(nil).AttachRequestID), requestID, eventType, eventID)
|
|
}
|
|
|
|
// ChasmEnabled mocks base method.
|
|
func (m *MockMutableState) ChasmEnabled() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ChasmEnabled")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// ChasmEnabled indicates an expected call of ChasmEnabled.
|
|
func (mr *MockMutableStateMockRecorder) ChasmEnabled() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChasmEnabled", reflect.TypeOf((*MockMutableState)(nil).ChasmEnabled))
|
|
}
|
|
|
|
// ChasmTree mocks base method.
|
|
func (m *MockMutableState) ChasmTree() ChasmTree {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ChasmTree")
|
|
ret0, _ := ret[0].(ChasmTree)
|
|
return ret0
|
|
}
|
|
|
|
// ChasmTree indicates an expected call of ChasmTree.
|
|
func (mr *MockMutableStateMockRecorder) ChasmTree() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChasmTree", reflect.TypeOf((*MockMutableState)(nil).ChasmTree))
|
|
}
|
|
|
|
// ChasmWorkflowComponent mocks base method.
|
|
func (m *MockMutableState) ChasmWorkflowComponent(ctx context.Context) (*workflow1.Workflow, chasm.MutableContext, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ChasmWorkflowComponent", ctx)
|
|
ret0, _ := ret[0].(*workflow1.Workflow)
|
|
ret1, _ := ret[1].(chasm.MutableContext)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// ChasmWorkflowComponent indicates an expected call of ChasmWorkflowComponent.
|
|
func (mr *MockMutableStateMockRecorder) ChasmWorkflowComponent(ctx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChasmWorkflowComponent", reflect.TypeOf((*MockMutableState)(nil).ChasmWorkflowComponent), ctx)
|
|
}
|
|
|
|
// ChasmWorkflowComponentReadOnly mocks base method.
|
|
func (m *MockMutableState) ChasmWorkflowComponentReadOnly(ctx context.Context) (*workflow1.Workflow, chasm.Context, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ChasmWorkflowComponentReadOnly", ctx)
|
|
ret0, _ := ret[0].(*workflow1.Workflow)
|
|
ret1, _ := ret[1].(chasm.Context)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// ChasmWorkflowComponentReadOnly indicates an expected call of ChasmWorkflowComponentReadOnly.
|
|
func (mr *MockMutableStateMockRecorder) ChasmWorkflowComponentReadOnly(ctx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChasmWorkflowComponentReadOnly", reflect.TypeOf((*MockMutableState)(nil).ChasmWorkflowComponentReadOnly), ctx)
|
|
}
|
|
|
|
// CheckResettable mocks base method.
|
|
func (m *MockMutableState) CheckResettable() error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CheckResettable")
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// CheckResettable indicates an expected call of CheckResettable.
|
|
func (mr *MockMutableStateMockRecorder) CheckResettable() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckResettable", reflect.TypeOf((*MockMutableState)(nil).CheckResettable))
|
|
}
|
|
|
|
// CheckSpeculativeWorkflowTaskTimeoutTask mocks base method.
|
|
func (m *MockMutableState) CheckSpeculativeWorkflowTaskTimeoutTask(task *tasks.WorkflowTaskTimeoutTask) bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CheckSpeculativeWorkflowTaskTimeoutTask", task)
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// CheckSpeculativeWorkflowTaskTimeoutTask indicates an expected call of CheckSpeculativeWorkflowTaskTimeoutTask.
|
|
func (mr *MockMutableStateMockRecorder) CheckSpeculativeWorkflowTaskTimeoutTask(task any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckSpeculativeWorkflowTaskTimeoutTask", reflect.TypeOf((*MockMutableState)(nil).CheckSpeculativeWorkflowTaskTimeoutTask), task)
|
|
}
|
|
|
|
// ClearStickyTaskQueue mocks base method.
|
|
func (m *MockMutableState) ClearStickyTaskQueue() {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "ClearStickyTaskQueue")
|
|
}
|
|
|
|
// ClearStickyTaskQueue indicates an expected call of ClearStickyTaskQueue.
|
|
func (mr *MockMutableStateMockRecorder) ClearStickyTaskQueue() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearStickyTaskQueue", reflect.TypeOf((*MockMutableState)(nil).ClearStickyTaskQueue))
|
|
}
|
|
|
|
// ClearTransientWorkflowTask mocks base method.
|
|
func (m *MockMutableState) ClearTransientWorkflowTask() error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ClearTransientWorkflowTask")
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ClearTransientWorkflowTask indicates an expected call of ClearTransientWorkflowTask.
|
|
func (mr *MockMutableStateMockRecorder) ClearTransientWorkflowTask() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearTransientWorkflowTask", reflect.TypeOf((*MockMutableState)(nil).ClearTransientWorkflowTask))
|
|
}
|
|
|
|
// CloneToProto mocks base method.
|
|
func (m *MockMutableState) CloneToProto() *persistence.WorkflowMutableState {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CloneToProto")
|
|
ret0, _ := ret[0].(*persistence.WorkflowMutableState)
|
|
return ret0
|
|
}
|
|
|
|
// CloneToProto indicates an expected call of CloneToProto.
|
|
func (mr *MockMutableStateMockRecorder) CloneToProto() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloneToProto", reflect.TypeOf((*MockMutableState)(nil).CloneToProto))
|
|
}
|
|
|
|
// CloseTransactionAsMutation mocks base method.
|
|
func (m *MockMutableState) CloseTransactionAsMutation(ctx context.Context, transactionPolicy TransactionPolicy) (*persistence0.WorkflowMutation, []*persistence0.WorkflowEvents, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CloseTransactionAsMutation", ctx, transactionPolicy)
|
|
ret0, _ := ret[0].(*persistence0.WorkflowMutation)
|
|
ret1, _ := ret[1].([]*persistence0.WorkflowEvents)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// CloseTransactionAsMutation indicates an expected call of CloseTransactionAsMutation.
|
|
func (mr *MockMutableStateMockRecorder) CloseTransactionAsMutation(ctx, transactionPolicy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseTransactionAsMutation", reflect.TypeOf((*MockMutableState)(nil).CloseTransactionAsMutation), ctx, transactionPolicy)
|
|
}
|
|
|
|
// CloseTransactionAsSnapshot mocks base method.
|
|
func (m *MockMutableState) CloseTransactionAsSnapshot(ctx context.Context, transactionPolicy TransactionPolicy) (*persistence0.WorkflowSnapshot, []*persistence0.WorkflowEvents, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CloseTransactionAsSnapshot", ctx, transactionPolicy)
|
|
ret0, _ := ret[0].(*persistence0.WorkflowSnapshot)
|
|
ret1, _ := ret[1].([]*persistence0.WorkflowEvents)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// CloseTransactionAsSnapshot indicates an expected call of CloseTransactionAsSnapshot.
|
|
func (mr *MockMutableStateMockRecorder) CloseTransactionAsSnapshot(ctx, transactionPolicy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseTransactionAsSnapshot", reflect.TypeOf((*MockMutableState)(nil).CloseTransactionAsSnapshot), ctx, transactionPolicy)
|
|
}
|
|
|
|
// ContinueAsNewMinBackoff mocks base method.
|
|
func (m *MockMutableState) ContinueAsNewMinBackoff(backoffDuration *durationpb.Duration) *durationpb.Duration {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ContinueAsNewMinBackoff", backoffDuration)
|
|
ret0, _ := ret[0].(*durationpb.Duration)
|
|
return ret0
|
|
}
|
|
|
|
// ContinueAsNewMinBackoff indicates an expected call of ContinueAsNewMinBackoff.
|
|
func (mr *MockMutableStateMockRecorder) ContinueAsNewMinBackoff(backoffDuration any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContinueAsNewMinBackoff", reflect.TypeOf((*MockMutableState)(nil).ContinueAsNewMinBackoff), backoffDuration)
|
|
}
|
|
|
|
// CurrentTaskQueue mocks base method.
|
|
func (m *MockMutableState) CurrentTaskQueue() *taskqueue.TaskQueue {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CurrentTaskQueue")
|
|
ret0, _ := ret[0].(*taskqueue.TaskQueue)
|
|
return ret0
|
|
}
|
|
|
|
// CurrentTaskQueue indicates an expected call of CurrentTaskQueue.
|
|
func (mr *MockMutableStateMockRecorder) CurrentTaskQueue() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentTaskQueue", reflect.TypeOf((*MockMutableState)(nil).CurrentTaskQueue))
|
|
}
|
|
|
|
// CurrentVersionedTransition mocks base method.
|
|
func (m *MockMutableState) CurrentVersionedTransition() *persistence.VersionedTransition {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CurrentVersionedTransition")
|
|
ret0, _ := ret[0].(*persistence.VersionedTransition)
|
|
return ret0
|
|
}
|
|
|
|
// CurrentVersionedTransition indicates an expected call of CurrentVersionedTransition.
|
|
func (mr *MockMutableStateMockRecorder) CurrentVersionedTransition() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentVersionedTransition", reflect.TypeOf((*MockMutableState)(nil).CurrentVersionedTransition))
|
|
}
|
|
|
|
// DeleteCHASMPureTasks mocks base method.
|
|
func (m *MockMutableState) DeleteCHASMPureTasks(maxScheduledTime time.Time) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "DeleteCHASMPureTasks", maxScheduledTime)
|
|
}
|
|
|
|
// DeleteCHASMPureTasks indicates an expected call of DeleteCHASMPureTasks.
|
|
func (mr *MockMutableStateMockRecorder) DeleteCHASMPureTasks(maxScheduledTime any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCHASMPureTasks", reflect.TypeOf((*MockMutableState)(nil).DeleteCHASMPureTasks), maxScheduledTime)
|
|
}
|
|
|
|
// DeleteSignalRequested mocks base method.
|
|
func (m *MockMutableState) DeleteSignalRequested(requestID string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "DeleteSignalRequested", requestID)
|
|
}
|
|
|
|
// DeleteSignalRequested indicates an expected call of DeleteSignalRequested.
|
|
func (mr *MockMutableStateMockRecorder) DeleteSignalRequested(requestID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSignalRequested", reflect.TypeOf((*MockMutableState)(nil).DeleteSignalRequested), requestID)
|
|
}
|
|
|
|
// DeleteSubStateMachine mocks base method.
|
|
func (m *MockMutableState) DeleteSubStateMachine(path *persistence.StateMachinePath) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteSubStateMachine", path)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DeleteSubStateMachine indicates an expected call of DeleteSubStateMachine.
|
|
func (mr *MockMutableStateMockRecorder) DeleteSubStateMachine(path any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubStateMachine", reflect.TypeOf((*MockMutableState)(nil).DeleteSubStateMachine), path)
|
|
}
|
|
|
|
// FlushBufferedEvents mocks base method.
|
|
func (m *MockMutableState) FlushBufferedEvents() {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "FlushBufferedEvents")
|
|
}
|
|
|
|
// FlushBufferedEvents indicates an expected call of FlushBufferedEvents.
|
|
func (mr *MockMutableStateMockRecorder) FlushBufferedEvents() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushBufferedEvents", reflect.TypeOf((*MockMutableState)(nil).FlushBufferedEvents))
|
|
}
|
|
|
|
// GenerateMigrationTasks mocks base method.
|
|
func (m *MockMutableState) GenerateMigrationTasks(targetClusters []string) ([]tasks.Task, int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GenerateMigrationTasks", targetClusters)
|
|
ret0, _ := ret[0].([]tasks.Task)
|
|
ret1, _ := ret[1].(int64)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GenerateMigrationTasks indicates an expected call of GenerateMigrationTasks.
|
|
func (mr *MockMutableStateMockRecorder) GenerateMigrationTasks(targetClusters any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateMigrationTasks", reflect.TypeOf((*MockMutableState)(nil).GenerateMigrationTasks), targetClusters)
|
|
}
|
|
|
|
// GetActivityByActivityID mocks base method.
|
|
func (m *MockMutableState) GetActivityByActivityID(arg0 string) (*persistence.ActivityInfo, bool) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetActivityByActivityID", arg0)
|
|
ret0, _ := ret[0].(*persistence.ActivityInfo)
|
|
ret1, _ := ret[1].(bool)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetActivityByActivityID indicates an expected call of GetActivityByActivityID.
|
|
func (mr *MockMutableStateMockRecorder) GetActivityByActivityID(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActivityByActivityID", reflect.TypeOf((*MockMutableState)(nil).GetActivityByActivityID), arg0)
|
|
}
|
|
|
|
// GetActivityInfo mocks base method.
|
|
func (m *MockMutableState) GetActivityInfo(arg0 int64) (*persistence.ActivityInfo, bool) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetActivityInfo", arg0)
|
|
ret0, _ := ret[0].(*persistence.ActivityInfo)
|
|
ret1, _ := ret[1].(bool)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetActivityInfo indicates an expected call of GetActivityInfo.
|
|
func (mr *MockMutableStateMockRecorder) GetActivityInfo(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActivityInfo", reflect.TypeOf((*MockMutableState)(nil).GetActivityInfo), arg0)
|
|
}
|
|
|
|
// GetActivityInfoWithTimerHeartbeat mocks base method.
|
|
func (m *MockMutableState) GetActivityInfoWithTimerHeartbeat(scheduledEventID int64) (*persistence.ActivityInfo, time.Time, bool) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetActivityInfoWithTimerHeartbeat", scheduledEventID)
|
|
ret0, _ := ret[0].(*persistence.ActivityInfo)
|
|
ret1, _ := ret[1].(time.Time)
|
|
ret2, _ := ret[2].(bool)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetActivityInfoWithTimerHeartbeat indicates an expected call of GetActivityInfoWithTimerHeartbeat.
|
|
func (mr *MockMutableStateMockRecorder) GetActivityInfoWithTimerHeartbeat(scheduledEventID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActivityInfoWithTimerHeartbeat", reflect.TypeOf((*MockMutableState)(nil).GetActivityInfoWithTimerHeartbeat), scheduledEventID)
|
|
}
|
|
|
|
// GetActivityScheduledEvent mocks base method.
|
|
func (m *MockMutableState) GetActivityScheduledEvent(arg0 context.Context, arg1 int64) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetActivityScheduledEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetActivityScheduledEvent indicates an expected call of GetActivityScheduledEvent.
|
|
func (mr *MockMutableStateMockRecorder) GetActivityScheduledEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActivityScheduledEvent", reflect.TypeOf((*MockMutableState)(nil).GetActivityScheduledEvent), arg0, arg1)
|
|
}
|
|
|
|
// GetActivityType mocks base method.
|
|
func (m *MockMutableState) GetActivityType(arg0 context.Context, arg1 *persistence.ActivityInfo) (*common.ActivityType, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetActivityType", arg0, arg1)
|
|
ret0, _ := ret[0].(*common.ActivityType)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetActivityType indicates an expected call of GetActivityType.
|
|
func (mr *MockMutableStateMockRecorder) GetActivityType(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActivityType", reflect.TypeOf((*MockMutableState)(nil).GetActivityType), arg0, arg1)
|
|
}
|
|
|
|
// GetApproximatePersistedSize mocks base method.
|
|
func (m *MockMutableState) GetApproximatePersistedSize() int {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetApproximatePersistedSize")
|
|
ret0, _ := ret[0].(int)
|
|
return ret0
|
|
}
|
|
|
|
// GetApproximatePersistedSize indicates an expected call of GetApproximatePersistedSize.
|
|
func (mr *MockMutableStateMockRecorder) GetApproximatePersistedSize() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetApproximatePersistedSize", reflect.TypeOf((*MockMutableState)(nil).GetApproximatePersistedSize))
|
|
}
|
|
|
|
// GetAssignedBuildId mocks base method.
|
|
func (m *MockMutableState) GetAssignedBuildId() string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetAssignedBuildId")
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// GetAssignedBuildId indicates an expected call of GetAssignedBuildId.
|
|
func (mr *MockMutableStateMockRecorder) GetAssignedBuildId() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssignedBuildId", reflect.TypeOf((*MockMutableState)(nil).GetAssignedBuildId))
|
|
}
|
|
|
|
// GetBaseWorkflowInfo mocks base method.
|
|
func (m *MockMutableState) GetBaseWorkflowInfo() *workflow0.BaseExecutionInfo {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetBaseWorkflowInfo")
|
|
ret0, _ := ret[0].(*workflow0.BaseExecutionInfo)
|
|
return ret0
|
|
}
|
|
|
|
// GetBaseWorkflowInfo indicates an expected call of GetBaseWorkflowInfo.
|
|
func (mr *MockMutableStateMockRecorder) GetBaseWorkflowInfo() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBaseWorkflowInfo", reflect.TypeOf((*MockMutableState)(nil).GetBaseWorkflowInfo))
|
|
}
|
|
|
|
// GetChildExecutionInfo mocks base method.
|
|
func (m *MockMutableState) GetChildExecutionInfo(arg0 int64) (*persistence.ChildExecutionInfo, bool) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetChildExecutionInfo", arg0)
|
|
ret0, _ := ret[0].(*persistence.ChildExecutionInfo)
|
|
ret1, _ := ret[1].(bool)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetChildExecutionInfo indicates an expected call of GetChildExecutionInfo.
|
|
func (mr *MockMutableStateMockRecorder) GetChildExecutionInfo(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChildExecutionInfo", reflect.TypeOf((*MockMutableState)(nil).GetChildExecutionInfo), arg0)
|
|
}
|
|
|
|
// GetChildExecutionInitiatedEvent mocks base method.
|
|
func (m *MockMutableState) GetChildExecutionInitiatedEvent(arg0 context.Context, arg1 int64) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetChildExecutionInitiatedEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetChildExecutionInitiatedEvent indicates an expected call of GetChildExecutionInitiatedEvent.
|
|
func (mr *MockMutableStateMockRecorder) GetChildExecutionInitiatedEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChildExecutionInitiatedEvent", reflect.TypeOf((*MockMutableState)(nil).GetChildExecutionInitiatedEvent), arg0, arg1)
|
|
}
|
|
|
|
// GetChildrenInitializedPostResetPoint mocks base method.
|
|
func (m *MockMutableState) GetChildrenInitializedPostResetPoint() map[string]*persistence.ResetChildInfo {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetChildrenInitializedPostResetPoint")
|
|
ret0, _ := ret[0].(map[string]*persistence.ResetChildInfo)
|
|
return ret0
|
|
}
|
|
|
|
// GetChildrenInitializedPostResetPoint indicates an expected call of GetChildrenInitializedPostResetPoint.
|
|
func (mr *MockMutableStateMockRecorder) GetChildrenInitializedPostResetPoint() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChildrenInitializedPostResetPoint", reflect.TypeOf((*MockMutableState)(nil).GetChildrenInitializedPostResetPoint))
|
|
}
|
|
|
|
// GetCloseVersion mocks base method.
|
|
func (m *MockMutableState) GetCloseVersion() (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetCloseVersion")
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetCloseVersion indicates an expected call of GetCloseVersion.
|
|
func (mr *MockMutableStateMockRecorder) GetCloseVersion() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCloseVersion", reflect.TypeOf((*MockMutableState)(nil).GetCloseVersion))
|
|
}
|
|
|
|
// GetCompletionEvent mocks base method.
|
|
func (m *MockMutableState) GetCompletionEvent(arg0 context.Context) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetCompletionEvent", arg0)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetCompletionEvent indicates an expected call of GetCompletionEvent.
|
|
func (mr *MockMutableStateMockRecorder) GetCompletionEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCompletionEvent", reflect.TypeOf((*MockMutableState)(nil).GetCompletionEvent), arg0)
|
|
}
|
|
|
|
// GetCronBackoffDuration mocks base method.
|
|
func (m *MockMutableState) GetCronBackoffDuration() time.Duration {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetCronBackoffDuration")
|
|
ret0, _ := ret[0].(time.Duration)
|
|
return ret0
|
|
}
|
|
|
|
// GetCronBackoffDuration indicates an expected call of GetCronBackoffDuration.
|
|
func (mr *MockMutableStateMockRecorder) GetCronBackoffDuration() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCronBackoffDuration", reflect.TypeOf((*MockMutableState)(nil).GetCronBackoffDuration))
|
|
}
|
|
|
|
// GetCurrentBranchToken mocks base method.
|
|
func (m *MockMutableState) GetCurrentBranchToken() ([]byte, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetCurrentBranchToken")
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetCurrentBranchToken indicates an expected call of GetCurrentBranchToken.
|
|
func (mr *MockMutableStateMockRecorder) GetCurrentBranchToken() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentBranchToken", reflect.TypeOf((*MockMutableState)(nil).GetCurrentBranchToken))
|
|
}
|
|
|
|
// GetCurrentVersion mocks base method.
|
|
func (m *MockMutableState) GetCurrentVersion() int64 {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetCurrentVersion")
|
|
ret0, _ := ret[0].(int64)
|
|
return ret0
|
|
}
|
|
|
|
// GetCurrentVersion indicates an expected call of GetCurrentVersion.
|
|
func (mr *MockMutableStateMockRecorder) GetCurrentVersion() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentVersion", reflect.TypeOf((*MockMutableState)(nil).GetCurrentVersion))
|
|
}
|
|
|
|
// GetDeploymentTransition mocks base method.
|
|
func (m *MockMutableState) GetDeploymentTransition() *workflow.DeploymentTransition {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetDeploymentTransition")
|
|
ret0, _ := ret[0].(*workflow.DeploymentTransition)
|
|
return ret0
|
|
}
|
|
|
|
// GetDeploymentTransition indicates an expected call of GetDeploymentTransition.
|
|
func (mr *MockMutableStateMockRecorder) GetDeploymentTransition() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeploymentTransition", reflect.TypeOf((*MockMutableState)(nil).GetDeploymentTransition))
|
|
}
|
|
|
|
// GetEffectiveDeployment mocks base method.
|
|
func (m *MockMutableState) GetEffectiveDeployment() *deployment.Deployment {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetEffectiveDeployment")
|
|
ret0, _ := ret[0].(*deployment.Deployment)
|
|
return ret0
|
|
}
|
|
|
|
// GetEffectiveDeployment indicates an expected call of GetEffectiveDeployment.
|
|
func (mr *MockMutableStateMockRecorder) GetEffectiveDeployment() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEffectiveDeployment", reflect.TypeOf((*MockMutableState)(nil).GetEffectiveDeployment))
|
|
}
|
|
|
|
// GetEffectiveVersioningBehavior mocks base method.
|
|
func (m *MockMutableState) GetEffectiveVersioningBehavior() enums.VersioningBehavior {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetEffectiveVersioningBehavior")
|
|
ret0, _ := ret[0].(enums.VersioningBehavior)
|
|
return ret0
|
|
}
|
|
|
|
// GetEffectiveVersioningBehavior indicates an expected call of GetEffectiveVersioningBehavior.
|
|
func (mr *MockMutableStateMockRecorder) GetEffectiveVersioningBehavior() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEffectiveVersioningBehavior", reflect.TypeOf((*MockMutableState)(nil).GetEffectiveVersioningBehavior))
|
|
}
|
|
|
|
// GetExecutionInfo mocks base method.
|
|
func (m *MockMutableState) GetExecutionInfo() *persistence.WorkflowExecutionInfo {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetExecutionInfo")
|
|
ret0, _ := ret[0].(*persistence.WorkflowExecutionInfo)
|
|
return ret0
|
|
}
|
|
|
|
// GetExecutionInfo indicates an expected call of GetExecutionInfo.
|
|
func (mr *MockMutableStateMockRecorder) GetExecutionInfo() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExecutionInfo", reflect.TypeOf((*MockMutableState)(nil).GetExecutionInfo))
|
|
}
|
|
|
|
// GetExecutionState mocks base method.
|
|
func (m *MockMutableState) GetExecutionState() *persistence.WorkflowExecutionState {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetExecutionState")
|
|
ret0, _ := ret[0].(*persistence.WorkflowExecutionState)
|
|
return ret0
|
|
}
|
|
|
|
// GetExecutionState indicates an expected call of GetExecutionState.
|
|
func (mr *MockMutableStateMockRecorder) GetExecutionState() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExecutionState", reflect.TypeOf((*MockMutableState)(nil).GetExecutionState))
|
|
}
|
|
|
|
// GetExternalPayloadCount mocks base method.
|
|
func (m *MockMutableState) GetExternalPayloadCount() int64 {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetExternalPayloadCount")
|
|
ret0, _ := ret[0].(int64)
|
|
return ret0
|
|
}
|
|
|
|
// GetExternalPayloadCount indicates an expected call of GetExternalPayloadCount.
|
|
func (mr *MockMutableStateMockRecorder) GetExternalPayloadCount() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExternalPayloadCount", reflect.TypeOf((*MockMutableState)(nil).GetExternalPayloadCount))
|
|
}
|
|
|
|
// GetExternalPayloadSize mocks base method.
|
|
func (m *MockMutableState) GetExternalPayloadSize() int64 {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetExternalPayloadSize")
|
|
ret0, _ := ret[0].(int64)
|
|
return ret0
|
|
}
|
|
|
|
// GetExternalPayloadSize indicates an expected call of GetExternalPayloadSize.
|
|
func (mr *MockMutableStateMockRecorder) GetExternalPayloadSize() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExternalPayloadSize", reflect.TypeOf((*MockMutableState)(nil).GetExternalPayloadSize))
|
|
}
|
|
|
|
// GetFirstRunID mocks base method.
|
|
func (m *MockMutableState) GetFirstRunID(ctx context.Context) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetFirstRunID", ctx)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetFirstRunID indicates an expected call of GetFirstRunID.
|
|
func (mr *MockMutableStateMockRecorder) GetFirstRunID(ctx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirstRunID", reflect.TypeOf((*MockMutableState)(nil).GetFirstRunID), ctx)
|
|
}
|
|
|
|
// GetHistorySize mocks base method.
|
|
func (m *MockMutableState) GetHistorySize() int64 {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetHistorySize")
|
|
ret0, _ := ret[0].(int64)
|
|
return ret0
|
|
}
|
|
|
|
// GetHistorySize indicates an expected call of GetHistorySize.
|
|
func (mr *MockMutableStateMockRecorder) GetHistorySize() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistorySize", reflect.TypeOf((*MockMutableState)(nil).GetHistorySize))
|
|
}
|
|
|
|
// GetInheritedBuildId mocks base method.
|
|
func (m *MockMutableState) GetInheritedBuildId() string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetInheritedBuildId")
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// GetInheritedBuildId indicates an expected call of GetInheritedBuildId.
|
|
func (mr *MockMutableStateMockRecorder) GetInheritedBuildId() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInheritedBuildId", reflect.TypeOf((*MockMutableState)(nil).GetInheritedBuildId))
|
|
}
|
|
|
|
// GetLastCompletedWorkflowTaskStartedEventId mocks base method.
|
|
func (m *MockMutableState) GetLastCompletedWorkflowTaskStartedEventId() int64 {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetLastCompletedWorkflowTaskStartedEventId")
|
|
ret0, _ := ret[0].(int64)
|
|
return ret0
|
|
}
|
|
|
|
// GetLastCompletedWorkflowTaskStartedEventId indicates an expected call of GetLastCompletedWorkflowTaskStartedEventId.
|
|
func (mr *MockMutableStateMockRecorder) GetLastCompletedWorkflowTaskStartedEventId() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastCompletedWorkflowTaskStartedEventId", reflect.TypeOf((*MockMutableState)(nil).GetLastCompletedWorkflowTaskStartedEventId))
|
|
}
|
|
|
|
// GetLastEventVersion mocks base method.
|
|
func (m *MockMutableState) GetLastEventVersion() (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetLastEventVersion")
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetLastEventVersion indicates an expected call of GetLastEventVersion.
|
|
func (mr *MockMutableStateMockRecorder) GetLastEventVersion() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastEventVersion", reflect.TypeOf((*MockMutableState)(nil).GetLastEventVersion))
|
|
}
|
|
|
|
// GetLastFirstEventIDTxnID mocks base method.
|
|
func (m *MockMutableState) GetLastFirstEventIDTxnID() (int64, int64) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetLastFirstEventIDTxnID")
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(int64)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetLastFirstEventIDTxnID indicates an expected call of GetLastFirstEventIDTxnID.
|
|
func (mr *MockMutableStateMockRecorder) GetLastFirstEventIDTxnID() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastFirstEventIDTxnID", reflect.TypeOf((*MockMutableState)(nil).GetLastFirstEventIDTxnID))
|
|
}
|
|
|
|
// GetLastWriteVersion mocks base method.
|
|
func (m *MockMutableState) GetLastWriteVersion() (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetLastWriteVersion")
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetLastWriteVersion indicates an expected call of GetLastWriteVersion.
|
|
func (mr *MockMutableStateMockRecorder) GetLastWriteVersion() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastWriteVersion", reflect.TypeOf((*MockMutableState)(nil).GetLastWriteVersion))
|
|
}
|
|
|
|
// GetMostRecentWorkerVersionStamp mocks base method.
|
|
func (m *MockMutableState) GetMostRecentWorkerVersionStamp() *common.WorkerVersionStamp {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetMostRecentWorkerVersionStamp")
|
|
ret0, _ := ret[0].(*common.WorkerVersionStamp)
|
|
return ret0
|
|
}
|
|
|
|
// GetMostRecentWorkerVersionStamp indicates an expected call of GetMostRecentWorkerVersionStamp.
|
|
func (mr *MockMutableStateMockRecorder) GetMostRecentWorkerVersionStamp() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMostRecentWorkerVersionStamp", reflect.TypeOf((*MockMutableState)(nil).GetMostRecentWorkerVersionStamp))
|
|
}
|
|
|
|
// GetNamespaceEntry mocks base method.
|
|
func (m *MockMutableState) GetNamespaceEntry() *namespace.Namespace {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetNamespaceEntry")
|
|
ret0, _ := ret[0].(*namespace.Namespace)
|
|
return ret0
|
|
}
|
|
|
|
// GetNamespaceEntry indicates an expected call of GetNamespaceEntry.
|
|
func (mr *MockMutableStateMockRecorder) GetNamespaceEntry() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaceEntry", reflect.TypeOf((*MockMutableState)(nil).GetNamespaceEntry))
|
|
}
|
|
|
|
// GetNextEventID mocks base method.
|
|
func (m *MockMutableState) GetNextEventID() int64 {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetNextEventID")
|
|
ret0, _ := ret[0].(int64)
|
|
return ret0
|
|
}
|
|
|
|
// GetNextEventID indicates an expected call of GetNextEventID.
|
|
func (mr *MockMutableStateMockRecorder) GetNextEventID() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNextEventID", reflect.TypeOf((*MockMutableState)(nil).GetNextEventID))
|
|
}
|
|
|
|
// GetPendingActivityInfos mocks base method.
|
|
func (m *MockMutableState) GetPendingActivityInfos() map[int64]*persistence.ActivityInfo {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPendingActivityInfos")
|
|
ret0, _ := ret[0].(map[int64]*persistence.ActivityInfo)
|
|
return ret0
|
|
}
|
|
|
|
// GetPendingActivityInfos indicates an expected call of GetPendingActivityInfos.
|
|
func (mr *MockMutableStateMockRecorder) GetPendingActivityInfos() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPendingActivityInfos", reflect.TypeOf((*MockMutableState)(nil).GetPendingActivityInfos))
|
|
}
|
|
|
|
// GetPendingChildExecutionInfos mocks base method.
|
|
func (m *MockMutableState) GetPendingChildExecutionInfos() map[int64]*persistence.ChildExecutionInfo {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPendingChildExecutionInfos")
|
|
ret0, _ := ret[0].(map[int64]*persistence.ChildExecutionInfo)
|
|
return ret0
|
|
}
|
|
|
|
// GetPendingChildExecutionInfos indicates an expected call of GetPendingChildExecutionInfos.
|
|
func (mr *MockMutableStateMockRecorder) GetPendingChildExecutionInfos() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPendingChildExecutionInfos", reflect.TypeOf((*MockMutableState)(nil).GetPendingChildExecutionInfos))
|
|
}
|
|
|
|
// GetPendingChildIds mocks base method.
|
|
func (m *MockMutableState) GetPendingChildIds() map[int64]struct{} {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPendingChildIds")
|
|
ret0, _ := ret[0].(map[int64]struct{})
|
|
return ret0
|
|
}
|
|
|
|
// GetPendingChildIds indicates an expected call of GetPendingChildIds.
|
|
func (mr *MockMutableStateMockRecorder) GetPendingChildIds() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPendingChildIds", reflect.TypeOf((*MockMutableState)(nil).GetPendingChildIds))
|
|
}
|
|
|
|
// GetPendingRequestCancelExternalInfos mocks base method.
|
|
func (m *MockMutableState) GetPendingRequestCancelExternalInfos() map[int64]*persistence.RequestCancelInfo {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPendingRequestCancelExternalInfos")
|
|
ret0, _ := ret[0].(map[int64]*persistence.RequestCancelInfo)
|
|
return ret0
|
|
}
|
|
|
|
// GetPendingRequestCancelExternalInfos indicates an expected call of GetPendingRequestCancelExternalInfos.
|
|
func (mr *MockMutableStateMockRecorder) GetPendingRequestCancelExternalInfos() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPendingRequestCancelExternalInfos", reflect.TypeOf((*MockMutableState)(nil).GetPendingRequestCancelExternalInfos))
|
|
}
|
|
|
|
// GetPendingSignalExternalInfos mocks base method.
|
|
func (m *MockMutableState) GetPendingSignalExternalInfos() map[int64]*persistence.SignalInfo {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPendingSignalExternalInfos")
|
|
ret0, _ := ret[0].(map[int64]*persistence.SignalInfo)
|
|
return ret0
|
|
}
|
|
|
|
// GetPendingSignalExternalInfos indicates an expected call of GetPendingSignalExternalInfos.
|
|
func (mr *MockMutableStateMockRecorder) GetPendingSignalExternalInfos() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPendingSignalExternalInfos", reflect.TypeOf((*MockMutableState)(nil).GetPendingSignalExternalInfos))
|
|
}
|
|
|
|
// GetPendingSignalRequestedIds mocks base method.
|
|
func (m *MockMutableState) GetPendingSignalRequestedIds() []string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPendingSignalRequestedIds")
|
|
ret0, _ := ret[0].([]string)
|
|
return ret0
|
|
}
|
|
|
|
// GetPendingSignalRequestedIds indicates an expected call of GetPendingSignalRequestedIds.
|
|
func (mr *MockMutableStateMockRecorder) GetPendingSignalRequestedIds() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPendingSignalRequestedIds", reflect.TypeOf((*MockMutableState)(nil).GetPendingSignalRequestedIds))
|
|
}
|
|
|
|
// GetPendingTimerInfos mocks base method.
|
|
func (m *MockMutableState) GetPendingTimerInfos() map[string]*persistence.TimerInfo {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPendingTimerInfos")
|
|
ret0, _ := ret[0].(map[string]*persistence.TimerInfo)
|
|
return ret0
|
|
}
|
|
|
|
// GetPendingTimerInfos indicates an expected call of GetPendingTimerInfos.
|
|
func (mr *MockMutableStateMockRecorder) GetPendingTimerInfos() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPendingTimerInfos", reflect.TypeOf((*MockMutableState)(nil).GetPendingTimerInfos))
|
|
}
|
|
|
|
// GetPendingWorkflowTask mocks base method.
|
|
func (m *MockMutableState) GetPendingWorkflowTask() *WorkflowTaskInfo {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetPendingWorkflowTask")
|
|
ret0, _ := ret[0].(*WorkflowTaskInfo)
|
|
return ret0
|
|
}
|
|
|
|
// GetPendingWorkflowTask indicates an expected call of GetPendingWorkflowTask.
|
|
func (mr *MockMutableStateMockRecorder) GetPendingWorkflowTask() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPendingWorkflowTask", reflect.TypeOf((*MockMutableState)(nil).GetPendingWorkflowTask))
|
|
}
|
|
|
|
// GetQueryRegistry mocks base method.
|
|
func (m *MockMutableState) GetQueryRegistry() QueryRegistry {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetQueryRegistry")
|
|
ret0, _ := ret[0].(QueryRegistry)
|
|
return ret0
|
|
}
|
|
|
|
// GetQueryRegistry indicates an expected call of GetQueryRegistry.
|
|
func (mr *MockMutableStateMockRecorder) GetQueryRegistry() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryRegistry", reflect.TypeOf((*MockMutableState)(nil).GetQueryRegistry))
|
|
}
|
|
|
|
// GetReapplyCandidateEvents mocks base method.
|
|
func (m *MockMutableState) GetReapplyCandidateEvents() []*history.HistoryEvent {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetReapplyCandidateEvents")
|
|
ret0, _ := ret[0].([]*history.HistoryEvent)
|
|
return ret0
|
|
}
|
|
|
|
// GetReapplyCandidateEvents indicates an expected call of GetReapplyCandidateEvents.
|
|
func (mr *MockMutableStateMockRecorder) GetReapplyCandidateEvents() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReapplyCandidateEvents", reflect.TypeOf((*MockMutableState)(nil).GetReapplyCandidateEvents))
|
|
}
|
|
|
|
// GetRequestCancelInfo mocks base method.
|
|
func (m *MockMutableState) GetRequestCancelInfo(arg0 int64) (*persistence.RequestCancelInfo, bool) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetRequestCancelInfo", arg0)
|
|
ret0, _ := ret[0].(*persistence.RequestCancelInfo)
|
|
ret1, _ := ret[1].(bool)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetRequestCancelInfo indicates an expected call of GetRequestCancelInfo.
|
|
func (mr *MockMutableStateMockRecorder) GetRequestCancelInfo(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRequestCancelInfo", reflect.TypeOf((*MockMutableState)(nil).GetRequestCancelInfo), arg0)
|
|
}
|
|
|
|
// GetRequesteCancelExternalInitiatedEvent mocks base method.
|
|
func (m *MockMutableState) GetRequesteCancelExternalInitiatedEvent(arg0 context.Context, arg1 int64) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetRequesteCancelExternalInitiatedEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetRequesteCancelExternalInitiatedEvent indicates an expected call of GetRequesteCancelExternalInitiatedEvent.
|
|
func (mr *MockMutableStateMockRecorder) GetRequesteCancelExternalInitiatedEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRequesteCancelExternalInitiatedEvent", reflect.TypeOf((*MockMutableState)(nil).GetRequesteCancelExternalInitiatedEvent), arg0, arg1)
|
|
}
|
|
|
|
// GetRetryBackoffDuration mocks base method.
|
|
func (m *MockMutableState) GetRetryBackoffDuration(arg0 *failure.Failure) (time.Duration, enums.RetryState) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetRetryBackoffDuration", arg0)
|
|
ret0, _ := ret[0].(time.Duration)
|
|
ret1, _ := ret[1].(enums.RetryState)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetRetryBackoffDuration indicates an expected call of GetRetryBackoffDuration.
|
|
func (mr *MockMutableStateMockRecorder) GetRetryBackoffDuration(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetryBackoffDuration", reflect.TypeOf((*MockMutableState)(nil).GetRetryBackoffDuration), arg0)
|
|
}
|
|
|
|
// GetSignalExternalInitiatedEvent mocks base method.
|
|
func (m *MockMutableState) GetSignalExternalInitiatedEvent(arg0 context.Context, arg1 int64) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetSignalExternalInitiatedEvent", arg0, arg1)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetSignalExternalInitiatedEvent indicates an expected call of GetSignalExternalInitiatedEvent.
|
|
func (mr *MockMutableStateMockRecorder) GetSignalExternalInitiatedEvent(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSignalExternalInitiatedEvent", reflect.TypeOf((*MockMutableState)(nil).GetSignalExternalInitiatedEvent), arg0, arg1)
|
|
}
|
|
|
|
// GetSignalInfo mocks base method.
|
|
func (m *MockMutableState) GetSignalInfo(arg0 int64) (*persistence.SignalInfo, bool) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetSignalInfo", arg0)
|
|
ret0, _ := ret[0].(*persistence.SignalInfo)
|
|
ret1, _ := ret[1].(bool)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetSignalInfo indicates an expected call of GetSignalInfo.
|
|
func (mr *MockMutableStateMockRecorder) GetSignalInfo(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSignalInfo", reflect.TypeOf((*MockMutableState)(nil).GetSignalInfo), arg0)
|
|
}
|
|
|
|
// GetStartEvent mocks base method.
|
|
func (m *MockMutableState) GetStartEvent(arg0 context.Context) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetStartEvent", arg0)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetStartEvent indicates an expected call of GetStartEvent.
|
|
func (mr *MockMutableStateMockRecorder) GetStartEvent(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStartEvent", reflect.TypeOf((*MockMutableState)(nil).GetStartEvent), arg0)
|
|
}
|
|
|
|
// GetStartVersion mocks base method.
|
|
func (m *MockMutableState) GetStartVersion() (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetStartVersion")
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetStartVersion indicates an expected call of GetStartVersion.
|
|
func (mr *MockMutableStateMockRecorder) GetStartVersion() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStartVersion", reflect.TypeOf((*MockMutableState)(nil).GetStartVersion))
|
|
}
|
|
|
|
// GetStartedWorkflowTask mocks base method.
|
|
func (m *MockMutableState) GetStartedWorkflowTask() *WorkflowTaskInfo {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetStartedWorkflowTask")
|
|
ret0, _ := ret[0].(*WorkflowTaskInfo)
|
|
return ret0
|
|
}
|
|
|
|
// GetStartedWorkflowTask indicates an expected call of GetStartedWorkflowTask.
|
|
func (mr *MockMutableStateMockRecorder) GetStartedWorkflowTask() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStartedWorkflowTask", reflect.TypeOf((*MockMutableState)(nil).GetStartedWorkflowTask))
|
|
}
|
|
|
|
// GetTransientWorkflowTaskInfo mocks base method.
|
|
func (m *MockMutableState) GetTransientWorkflowTaskInfo(workflowTask *WorkflowTaskInfo, identity string) *history0.TransientWorkflowTaskInfo {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetTransientWorkflowTaskInfo", workflowTask, identity)
|
|
ret0, _ := ret[0].(*history0.TransientWorkflowTaskInfo)
|
|
return ret0
|
|
}
|
|
|
|
// GetTransientWorkflowTaskInfo indicates an expected call of GetTransientWorkflowTaskInfo.
|
|
func (mr *MockMutableStateMockRecorder) GetTransientWorkflowTaskInfo(workflowTask, identity any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransientWorkflowTaskInfo", reflect.TypeOf((*MockMutableState)(nil).GetTransientWorkflowTaskInfo), workflowTask, identity)
|
|
}
|
|
|
|
// GetUpdateCondition mocks base method.
|
|
func (m *MockMutableState) GetUpdateCondition() (int64, int64) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetUpdateCondition")
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(int64)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetUpdateCondition indicates an expected call of GetUpdateCondition.
|
|
func (mr *MockMutableStateMockRecorder) GetUpdateCondition() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUpdateCondition", reflect.TypeOf((*MockMutableState)(nil).GetUpdateCondition))
|
|
}
|
|
|
|
// GetUpdateOutcome mocks base method.
|
|
func (m *MockMutableState) GetUpdateOutcome(ctx context.Context, updateID string) (*update.Outcome, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetUpdateOutcome", ctx, updateID)
|
|
ret0, _ := ret[0].(*update.Outcome)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetUpdateOutcome indicates an expected call of GetUpdateOutcome.
|
|
func (mr *MockMutableStateMockRecorder) GetUpdateOutcome(ctx, updateID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUpdateOutcome", reflect.TypeOf((*MockMutableState)(nil).GetUpdateOutcome), ctx, updateID)
|
|
}
|
|
|
|
// GetUserTimerInfo mocks base method.
|
|
func (m *MockMutableState) GetUserTimerInfo(arg0 string) (*persistence.TimerInfo, bool) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetUserTimerInfo", arg0)
|
|
ret0, _ := ret[0].(*persistence.TimerInfo)
|
|
ret1, _ := ret[1].(bool)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetUserTimerInfo indicates an expected call of GetUserTimerInfo.
|
|
func (mr *MockMutableStateMockRecorder) GetUserTimerInfo(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserTimerInfo", reflect.TypeOf((*MockMutableState)(nil).GetUserTimerInfo), arg0)
|
|
}
|
|
|
|
// GetUserTimerInfoByEventID mocks base method.
|
|
func (m *MockMutableState) GetUserTimerInfoByEventID(arg0 int64) (*persistence.TimerInfo, bool) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetUserTimerInfoByEventID", arg0)
|
|
ret0, _ := ret[0].(*persistence.TimerInfo)
|
|
ret1, _ := ret[1].(bool)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetUserTimerInfoByEventID indicates an expected call of GetUserTimerInfoByEventID.
|
|
func (mr *MockMutableStateMockRecorder) GetUserTimerInfoByEventID(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserTimerInfoByEventID", reflect.TypeOf((*MockMutableState)(nil).GetUserTimerInfoByEventID), arg0)
|
|
}
|
|
|
|
// GetVersioningRevisionNumber mocks base method.
|
|
func (m *MockMutableState) GetVersioningRevisionNumber() int64 {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetVersioningRevisionNumber")
|
|
ret0, _ := ret[0].(int64)
|
|
return ret0
|
|
}
|
|
|
|
// GetVersioningRevisionNumber indicates an expected call of GetVersioningRevisionNumber.
|
|
func (mr *MockMutableStateMockRecorder) GetVersioningRevisionNumber() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersioningRevisionNumber", reflect.TypeOf((*MockMutableState)(nil).GetVersioningRevisionNumber))
|
|
}
|
|
|
|
// GetWorkflowCloseTime mocks base method.
|
|
func (m *MockMutableState) GetWorkflowCloseTime(ctx context.Context) (time.Time, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkflowCloseTime", ctx)
|
|
ret0, _ := ret[0].(time.Time)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetWorkflowCloseTime indicates an expected call of GetWorkflowCloseTime.
|
|
func (mr *MockMutableStateMockRecorder) GetWorkflowCloseTime(ctx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowCloseTime", reflect.TypeOf((*MockMutableState)(nil).GetWorkflowCloseTime), ctx)
|
|
}
|
|
|
|
// GetWorkflowExecutionDuration mocks base method.
|
|
func (m *MockMutableState) GetWorkflowExecutionDuration(ctx context.Context) (time.Duration, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkflowExecutionDuration", ctx)
|
|
ret0, _ := ret[0].(time.Duration)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetWorkflowExecutionDuration indicates an expected call of GetWorkflowExecutionDuration.
|
|
func (mr *MockMutableStateMockRecorder) GetWorkflowExecutionDuration(ctx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowExecutionDuration", reflect.TypeOf((*MockMutableState)(nil).GetWorkflowExecutionDuration), ctx)
|
|
}
|
|
|
|
// GetWorkflowKey mocks base method.
|
|
func (m *MockMutableState) GetWorkflowKey() definition.WorkflowKey {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkflowKey")
|
|
ret0, _ := ret[0].(definition.WorkflowKey)
|
|
return ret0
|
|
}
|
|
|
|
// GetWorkflowKey indicates an expected call of GetWorkflowKey.
|
|
func (mr *MockMutableStateMockRecorder) GetWorkflowKey() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowKey", reflect.TypeOf((*MockMutableState)(nil).GetWorkflowKey))
|
|
}
|
|
|
|
// GetWorkflowStateStatus mocks base method.
|
|
func (m *MockMutableState) GetWorkflowStateStatus() (enums0.WorkflowExecutionState, enums.WorkflowExecutionStatus) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkflowStateStatus")
|
|
ret0, _ := ret[0].(enums0.WorkflowExecutionState)
|
|
ret1, _ := ret[1].(enums.WorkflowExecutionStatus)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetWorkflowStateStatus indicates an expected call of GetWorkflowStateStatus.
|
|
func (mr *MockMutableStateMockRecorder) GetWorkflowStateStatus() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowStateStatus", reflect.TypeOf((*MockMutableState)(nil).GetWorkflowStateStatus))
|
|
}
|
|
|
|
// GetWorkflowTaskByID mocks base method.
|
|
func (m *MockMutableState) GetWorkflowTaskByID(scheduledEventID int64) *WorkflowTaskInfo {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkflowTaskByID", scheduledEventID)
|
|
ret0, _ := ret[0].(*WorkflowTaskInfo)
|
|
return ret0
|
|
}
|
|
|
|
// GetWorkflowTaskByID indicates an expected call of GetWorkflowTaskByID.
|
|
func (mr *MockMutableStateMockRecorder) GetWorkflowTaskByID(scheduledEventID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowTaskByID", reflect.TypeOf((*MockMutableState)(nil).GetWorkflowTaskByID), scheduledEventID)
|
|
}
|
|
|
|
// GetWorkflowTaskScheduleToStartTimeoutTask mocks base method.
|
|
func (m *MockMutableState) GetWorkflowTaskScheduleToStartTimeoutTask() *tasks.WorkflowTaskTimeoutTask {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkflowTaskScheduleToStartTimeoutTask")
|
|
ret0, _ := ret[0].(*tasks.WorkflowTaskTimeoutTask)
|
|
return ret0
|
|
}
|
|
|
|
// GetWorkflowTaskScheduleToStartTimeoutTask indicates an expected call of GetWorkflowTaskScheduleToStartTimeoutTask.
|
|
func (mr *MockMutableStateMockRecorder) GetWorkflowTaskScheduleToStartTimeoutTask() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowTaskScheduleToStartTimeoutTask", reflect.TypeOf((*MockMutableState)(nil).GetWorkflowTaskScheduleToStartTimeoutTask))
|
|
}
|
|
|
|
// GetWorkflowTaskStartToCloseTimeoutTask mocks base method.
|
|
func (m *MockMutableState) GetWorkflowTaskStartToCloseTimeoutTask() *tasks.WorkflowTaskTimeoutTask {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkflowTaskStartToCloseTimeoutTask")
|
|
ret0, _ := ret[0].(*tasks.WorkflowTaskTimeoutTask)
|
|
return ret0
|
|
}
|
|
|
|
// GetWorkflowTaskStartToCloseTimeoutTask indicates an expected call of GetWorkflowTaskStartToCloseTimeoutTask.
|
|
func (mr *MockMutableStateMockRecorder) GetWorkflowTaskStartToCloseTimeoutTask() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowTaskStartToCloseTimeoutTask", reflect.TypeOf((*MockMutableState)(nil).GetWorkflowTaskStartToCloseTimeoutTask))
|
|
}
|
|
|
|
// GetWorkflowType mocks base method.
|
|
func (m *MockMutableState) GetWorkflowType() *common.WorkflowType {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkflowType")
|
|
ret0, _ := ret[0].(*common.WorkflowType)
|
|
return ret0
|
|
}
|
|
|
|
// GetWorkflowType indicates an expected call of GetWorkflowType.
|
|
func (mr *MockMutableStateMockRecorder) GetWorkflowType() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowType", reflect.TypeOf((*MockMutableState)(nil).GetWorkflowType))
|
|
}
|
|
|
|
// HSM mocks base method.
|
|
func (m *MockMutableState) HSM() *hsm.Node {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HSM")
|
|
ret0, _ := ret[0].(*hsm.Node)
|
|
return ret0
|
|
}
|
|
|
|
// HSM indicates an expected call of HSM.
|
|
func (mr *MockMutableStateMockRecorder) HSM() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSM", reflect.TypeOf((*MockMutableState)(nil).HSM))
|
|
}
|
|
|
|
// HadOrHasWorkflowTask mocks base method.
|
|
func (m *MockMutableState) HadOrHasWorkflowTask() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HadOrHasWorkflowTask")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// HadOrHasWorkflowTask indicates an expected call of HadOrHasWorkflowTask.
|
|
func (mr *MockMutableStateMockRecorder) HadOrHasWorkflowTask() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HadOrHasWorkflowTask", reflect.TypeOf((*MockMutableState)(nil).HadOrHasWorkflowTask))
|
|
}
|
|
|
|
// HasAnyBufferedEvent mocks base method.
|
|
func (m *MockMutableState) HasAnyBufferedEvent(filter historybuilder.BufferedEventFilter) bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HasAnyBufferedEvent", filter)
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// HasAnyBufferedEvent indicates an expected call of HasAnyBufferedEvent.
|
|
func (mr *MockMutableStateMockRecorder) HasAnyBufferedEvent(filter any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasAnyBufferedEvent", reflect.TypeOf((*MockMutableState)(nil).HasAnyBufferedEvent), filter)
|
|
}
|
|
|
|
// HasBufferedEvents mocks base method.
|
|
func (m *MockMutableState) HasBufferedEvents() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HasBufferedEvents")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// HasBufferedEvents indicates an expected call of HasBufferedEvents.
|
|
func (mr *MockMutableStateMockRecorder) HasBufferedEvents() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasBufferedEvents", reflect.TypeOf((*MockMutableState)(nil).HasBufferedEvents))
|
|
}
|
|
|
|
// HasCompletedAnyWorkflowTask mocks base method.
|
|
func (m *MockMutableState) HasCompletedAnyWorkflowTask() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HasCompletedAnyWorkflowTask")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// HasCompletedAnyWorkflowTask indicates an expected call of HasCompletedAnyWorkflowTask.
|
|
func (mr *MockMutableStateMockRecorder) HasCompletedAnyWorkflowTask() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasCompletedAnyWorkflowTask", reflect.TypeOf((*MockMutableState)(nil).HasCompletedAnyWorkflowTask))
|
|
}
|
|
|
|
// HasParentExecution mocks base method.
|
|
func (m *MockMutableState) HasParentExecution() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HasParentExecution")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// HasParentExecution indicates an expected call of HasParentExecution.
|
|
func (mr *MockMutableStateMockRecorder) HasParentExecution() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasParentExecution", reflect.TypeOf((*MockMutableState)(nil).HasParentExecution))
|
|
}
|
|
|
|
// HasPendingWorkflowTask mocks base method.
|
|
func (m *MockMutableState) HasPendingWorkflowTask() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HasPendingWorkflowTask")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// HasPendingWorkflowTask indicates an expected call of HasPendingWorkflowTask.
|
|
func (mr *MockMutableStateMockRecorder) HasPendingWorkflowTask() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasPendingWorkflowTask", reflect.TypeOf((*MockMutableState)(nil).HasPendingWorkflowTask))
|
|
}
|
|
|
|
// HasRequestID mocks base method.
|
|
func (m *MockMutableState) HasRequestID(requestID string) bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HasRequestID", requestID)
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// HasRequestID indicates an expected call of HasRequestID.
|
|
func (mr *MockMutableStateMockRecorder) HasRequestID(requestID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasRequestID", reflect.TypeOf((*MockMutableState)(nil).HasRequestID), requestID)
|
|
}
|
|
|
|
// HasStartedWorkflowTask mocks base method.
|
|
func (m *MockMutableState) HasStartedWorkflowTask() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HasStartedWorkflowTask")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// HasStartedWorkflowTask indicates an expected call of HasStartedWorkflowTask.
|
|
func (mr *MockMutableStateMockRecorder) HasStartedWorkflowTask() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasStartedWorkflowTask", reflect.TypeOf((*MockMutableState)(nil).HasStartedWorkflowTask))
|
|
}
|
|
|
|
// InitTransitionHistory mocks base method.
|
|
func (m *MockMutableState) InitTransitionHistory() {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "InitTransitionHistory")
|
|
}
|
|
|
|
// InitTransitionHistory indicates an expected call of InitTransitionHistory.
|
|
func (mr *MockMutableStateMockRecorder) InitTransitionHistory() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitTransitionHistory", reflect.TypeOf((*MockMutableState)(nil).InitTransitionHistory))
|
|
}
|
|
|
|
// IsCancelRequested mocks base method.
|
|
func (m *MockMutableState) IsCancelRequested() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsCancelRequested")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsCancelRequested indicates an expected call of IsCancelRequested.
|
|
func (mr *MockMutableStateMockRecorder) IsCancelRequested() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsCancelRequested", reflect.TypeOf((*MockMutableState)(nil).IsCancelRequested))
|
|
}
|
|
|
|
// IsCurrentWorkflowGuaranteed mocks base method.
|
|
func (m *MockMutableState) IsCurrentWorkflowGuaranteed() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsCurrentWorkflowGuaranteed")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsCurrentWorkflowGuaranteed indicates an expected call of IsCurrentWorkflowGuaranteed.
|
|
func (mr *MockMutableStateMockRecorder) IsCurrentWorkflowGuaranteed() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsCurrentWorkflowGuaranteed", reflect.TypeOf((*MockMutableState)(nil).IsCurrentWorkflowGuaranteed))
|
|
}
|
|
|
|
// IsDirty mocks base method.
|
|
func (m *MockMutableState) IsDirty() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsDirty")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsDirty indicates an expected call of IsDirty.
|
|
func (mr *MockMutableStateMockRecorder) IsDirty() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsDirty", reflect.TypeOf((*MockMutableState)(nil).IsDirty))
|
|
}
|
|
|
|
// IsNonCurrentWorkflowGuaranteed mocks base method.
|
|
func (m *MockMutableState) IsNonCurrentWorkflowGuaranteed() (bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsNonCurrentWorkflowGuaranteed")
|
|
ret0, _ := ret[0].(bool)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// IsNonCurrentWorkflowGuaranteed indicates an expected call of IsNonCurrentWorkflowGuaranteed.
|
|
func (mr *MockMutableStateMockRecorder) IsNonCurrentWorkflowGuaranteed() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNonCurrentWorkflowGuaranteed", reflect.TypeOf((*MockMutableState)(nil).IsNonCurrentWorkflowGuaranteed))
|
|
}
|
|
|
|
// IsResetRun mocks base method.
|
|
func (m *MockMutableState) IsResetRun() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsResetRun")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsResetRun indicates an expected call of IsResetRun.
|
|
func (mr *MockMutableStateMockRecorder) IsResetRun() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsResetRun", reflect.TypeOf((*MockMutableState)(nil).IsResetRun))
|
|
}
|
|
|
|
// IsResourceDuplicated mocks base method.
|
|
func (m *MockMutableState) IsResourceDuplicated(resourceDedupKey definition.DeduplicationID) bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsResourceDuplicated", resourceDedupKey)
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsResourceDuplicated indicates an expected call of IsResourceDuplicated.
|
|
func (mr *MockMutableStateMockRecorder) IsResourceDuplicated(resourceDedupKey any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsResourceDuplicated", reflect.TypeOf((*MockMutableState)(nil).IsResourceDuplicated), resourceDedupKey)
|
|
}
|
|
|
|
// IsSignalRequested mocks base method.
|
|
func (m *MockMutableState) IsSignalRequested(requestID string) bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsSignalRequested", requestID)
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsSignalRequested indicates an expected call of IsSignalRequested.
|
|
func (mr *MockMutableStateMockRecorder) IsSignalRequested(requestID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSignalRequested", reflect.TypeOf((*MockMutableState)(nil).IsSignalRequested), requestID)
|
|
}
|
|
|
|
// IsStickyTaskQueueSet mocks base method.
|
|
func (m *MockMutableState) IsStickyTaskQueueSet() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsStickyTaskQueueSet")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsStickyTaskQueueSet indicates an expected call of IsStickyTaskQueueSet.
|
|
func (mr *MockMutableStateMockRecorder) IsStickyTaskQueueSet() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsStickyTaskQueueSet", reflect.TypeOf((*MockMutableState)(nil).IsStickyTaskQueueSet))
|
|
}
|
|
|
|
// IsSubStateMachineDeleted mocks base method.
|
|
func (m *MockMutableState) IsSubStateMachineDeleted() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsSubStateMachineDeleted")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsSubStateMachineDeleted indicates an expected call of IsSubStateMachineDeleted.
|
|
func (mr *MockMutableStateMockRecorder) IsSubStateMachineDeleted() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSubStateMachineDeleted", reflect.TypeOf((*MockMutableState)(nil).IsSubStateMachineDeleted))
|
|
}
|
|
|
|
// IsTransientWorkflowTask mocks base method.
|
|
func (m *MockMutableState) IsTransientWorkflowTask() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsTransientWorkflowTask")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsTransientWorkflowTask indicates an expected call of IsTransientWorkflowTask.
|
|
func (mr *MockMutableStateMockRecorder) IsTransientWorkflowTask() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsTransientWorkflowTask", reflect.TypeOf((*MockMutableState)(nil).IsTransientWorkflowTask))
|
|
}
|
|
|
|
// IsTransitionHistoryEnabled mocks base method.
|
|
func (m *MockMutableState) IsTransitionHistoryEnabled() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsTransitionHistoryEnabled")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsTransitionHistoryEnabled indicates an expected call of IsTransitionHistoryEnabled.
|
|
func (mr *MockMutableStateMockRecorder) IsTransitionHistoryEnabled() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsTransitionHistoryEnabled", reflect.TypeOf((*MockMutableState)(nil).IsTransitionHistoryEnabled))
|
|
}
|
|
|
|
// IsWorkflow mocks base method.
|
|
func (m *MockMutableState) IsWorkflow() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsWorkflow")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsWorkflow indicates an expected call of IsWorkflow.
|
|
func (mr *MockMutableStateMockRecorder) IsWorkflow() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsWorkflow", reflect.TypeOf((*MockMutableState)(nil).IsWorkflow))
|
|
}
|
|
|
|
// IsWorkflowCloseAttempted mocks base method.
|
|
func (m *MockMutableState) IsWorkflowCloseAttempted() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsWorkflowCloseAttempted")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsWorkflowCloseAttempted indicates an expected call of IsWorkflowCloseAttempted.
|
|
func (mr *MockMutableStateMockRecorder) IsWorkflowCloseAttempted() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsWorkflowCloseAttempted", reflect.TypeOf((*MockMutableState)(nil).IsWorkflowCloseAttempted))
|
|
}
|
|
|
|
// IsWorkflowExecutionRunning mocks base method.
|
|
func (m *MockMutableState) IsWorkflowExecutionRunning() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsWorkflowExecutionRunning")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsWorkflowExecutionRunning indicates an expected call of IsWorkflowExecutionRunning.
|
|
func (mr *MockMutableStateMockRecorder) IsWorkflowExecutionRunning() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsWorkflowExecutionRunning", reflect.TypeOf((*MockMutableState)(nil).IsWorkflowExecutionRunning))
|
|
}
|
|
|
|
// IsWorkflowExecutionStatusPaused mocks base method.
|
|
func (m *MockMutableState) IsWorkflowExecutionStatusPaused() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsWorkflowExecutionStatusPaused")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsWorkflowExecutionStatusPaused indicates an expected call of IsWorkflowExecutionStatusPaused.
|
|
func (mr *MockMutableStateMockRecorder) IsWorkflowExecutionStatusPaused() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsWorkflowExecutionStatusPaused", reflect.TypeOf((*MockMutableState)(nil).IsWorkflowExecutionStatusPaused))
|
|
}
|
|
|
|
// IsWorkflowPendingOnWorkflowTaskBackoff mocks base method.
|
|
func (m *MockMutableState) IsWorkflowPendingOnWorkflowTaskBackoff() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsWorkflowPendingOnWorkflowTaskBackoff")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsWorkflowPendingOnWorkflowTaskBackoff indicates an expected call of IsWorkflowPendingOnWorkflowTaskBackoff.
|
|
func (mr *MockMutableStateMockRecorder) IsWorkflowPendingOnWorkflowTaskBackoff() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsWorkflowPendingOnWorkflowTaskBackoff", reflect.TypeOf((*MockMutableState)(nil).IsWorkflowPendingOnWorkflowTaskBackoff))
|
|
}
|
|
|
|
// LoadHistoryEvent mocks base method.
|
|
func (m *MockMutableState) LoadHistoryEvent(ctx context.Context, token []byte) (*history.HistoryEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "LoadHistoryEvent", ctx, token)
|
|
ret0, _ := ret[0].(*history.HistoryEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// LoadHistoryEvent indicates an expected call of LoadHistoryEvent.
|
|
func (mr *MockMutableStateMockRecorder) LoadHistoryEvent(ctx, token any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadHistoryEvent", reflect.TypeOf((*MockMutableState)(nil).LoadHistoryEvent), ctx, token)
|
|
}
|
|
|
|
// NextTransitionCount mocks base method.
|
|
func (m *MockMutableState) NextTransitionCount() int64 {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "NextTransitionCount")
|
|
ret0, _ := ret[0].(int64)
|
|
return ret0
|
|
}
|
|
|
|
// NextTransitionCount indicates an expected call of NextTransitionCount.
|
|
func (mr *MockMutableStateMockRecorder) NextTransitionCount() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NextTransitionCount", reflect.TypeOf((*MockMutableState)(nil).NextTransitionCount))
|
|
}
|
|
|
|
// PopTasks mocks base method.
|
|
func (m *MockMutableState) PopTasks() map[tasks.Category][]tasks.Task {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "PopTasks")
|
|
ret0, _ := ret[0].(map[tasks.Category][]tasks.Task)
|
|
return ret0
|
|
}
|
|
|
|
// PopTasks indicates an expected call of PopTasks.
|
|
func (mr *MockMutableStateMockRecorder) PopTasks() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PopTasks", reflect.TypeOf((*MockMutableState)(nil).PopTasks))
|
|
}
|
|
|
|
// RecordLastActivityCompleteTime mocks base method.
|
|
func (m *MockMutableState) RecordLastActivityCompleteTime(ai *persistence.ActivityInfo) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "RecordLastActivityCompleteTime", ai)
|
|
}
|
|
|
|
// RecordLastActivityCompleteTime indicates an expected call of RecordLastActivityCompleteTime.
|
|
func (mr *MockMutableStateMockRecorder) RecordLastActivityCompleteTime(ai any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordLastActivityCompleteTime", reflect.TypeOf((*MockMutableState)(nil).RecordLastActivityCompleteTime), ai)
|
|
}
|
|
|
|
// RefreshExpirationTimeoutTask mocks base method.
|
|
func (m *MockMutableState) RefreshExpirationTimeoutTask(ctx context.Context) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RefreshExpirationTimeoutTask", ctx)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// RefreshExpirationTimeoutTask indicates an expected call of RefreshExpirationTimeoutTask.
|
|
func (mr *MockMutableStateMockRecorder) RefreshExpirationTimeoutTask(ctx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshExpirationTimeoutTask", reflect.TypeOf((*MockMutableState)(nil).RefreshExpirationTimeoutTask), ctx)
|
|
}
|
|
|
|
// RegenerateActivityRetryTask mocks base method.
|
|
func (m *MockMutableState) RegenerateActivityRetryTask(ai *persistence.ActivityInfo, newScheduledTime time.Time) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RegenerateActivityRetryTask", ai, newScheduledTime)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// RegenerateActivityRetryTask indicates an expected call of RegenerateActivityRetryTask.
|
|
func (mr *MockMutableStateMockRecorder) RegenerateActivityRetryTask(ai, newScheduledTime any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegenerateActivityRetryTask", reflect.TypeOf((*MockMutableState)(nil).RegenerateActivityRetryTask), ai, newScheduledTime)
|
|
}
|
|
|
|
// RejectWorkflowExecutionUpdate mocks base method.
|
|
func (m *MockMutableState) RejectWorkflowExecutionUpdate(protocolInstanceID string, updRejection *update.Rejection) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RejectWorkflowExecutionUpdate", protocolInstanceID, updRejection)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// RejectWorkflowExecutionUpdate indicates an expected call of RejectWorkflowExecutionUpdate.
|
|
func (mr *MockMutableStateMockRecorder) RejectWorkflowExecutionUpdate(protocolInstanceID, updRejection any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectWorkflowExecutionUpdate", reflect.TypeOf((*MockMutableState)(nil).RejectWorkflowExecutionUpdate), protocolInstanceID, updRejection)
|
|
}
|
|
|
|
// RemoveSpeculativeWorkflowTaskTimeoutTask mocks base method.
|
|
func (m *MockMutableState) RemoveSpeculativeWorkflowTaskTimeoutTask() {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "RemoveSpeculativeWorkflowTaskTimeoutTask")
|
|
}
|
|
|
|
// RemoveSpeculativeWorkflowTaskTimeoutTask indicates an expected call of RemoveSpeculativeWorkflowTaskTimeoutTask.
|
|
func (mr *MockMutableStateMockRecorder) RemoveSpeculativeWorkflowTaskTimeoutTask() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveSpeculativeWorkflowTaskTimeoutTask", reflect.TypeOf((*MockMutableState)(nil).RemoveSpeculativeWorkflowTaskTimeoutTask))
|
|
}
|
|
|
|
// RetryActivity mocks base method.
|
|
func (m *MockMutableState) RetryActivity(ai *persistence.ActivityInfo, arg1 *failure.Failure) (enums.RetryState, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RetryActivity", ai, arg1)
|
|
ret0, _ := ret[0].(enums.RetryState)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RetryActivity indicates an expected call of RetryActivity.
|
|
func (mr *MockMutableStateMockRecorder) RetryActivity(ai, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetryActivity", reflect.TypeOf((*MockMutableState)(nil).RetryActivity), ai, arg1)
|
|
}
|
|
|
|
// SetBaseWorkflow mocks base method.
|
|
func (m *MockMutableState) SetBaseWorkflow(baseRunID string, baseRunLowestCommonAncestorEventID, baseRunLowestCommonAncestorEventVersion int64) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetBaseWorkflow", baseRunID, baseRunLowestCommonAncestorEventID, baseRunLowestCommonAncestorEventVersion)
|
|
}
|
|
|
|
// SetBaseWorkflow indicates an expected call of SetBaseWorkflow.
|
|
func (mr *MockMutableStateMockRecorder) SetBaseWorkflow(baseRunID, baseRunLowestCommonAncestorEventID, baseRunLowestCommonAncestorEventVersion any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBaseWorkflow", reflect.TypeOf((*MockMutableState)(nil).SetBaseWorkflow), baseRunID, baseRunLowestCommonAncestorEventID, baseRunLowestCommonAncestorEventVersion)
|
|
}
|
|
|
|
// SetChildrenInitializedPostResetPoint mocks base method.
|
|
func (m *MockMutableState) SetChildrenInitializedPostResetPoint(children map[string]*persistence.ResetChildInfo) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetChildrenInitializedPostResetPoint", children)
|
|
}
|
|
|
|
// SetChildrenInitializedPostResetPoint indicates an expected call of SetChildrenInitializedPostResetPoint.
|
|
func (mr *MockMutableStateMockRecorder) SetChildrenInitializedPostResetPoint(children any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetChildrenInitializedPostResetPoint", reflect.TypeOf((*MockMutableState)(nil).SetChildrenInitializedPostResetPoint), children)
|
|
}
|
|
|
|
// SetCurrentBranchToken mocks base method.
|
|
func (m *MockMutableState) SetCurrentBranchToken(branchToken []byte) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetCurrentBranchToken", branchToken)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SetCurrentBranchToken indicates an expected call of SetCurrentBranchToken.
|
|
func (mr *MockMutableStateMockRecorder) SetCurrentBranchToken(branchToken any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentBranchToken", reflect.TypeOf((*MockMutableState)(nil).SetCurrentBranchToken), branchToken)
|
|
}
|
|
|
|
// SetHistoryBuilder mocks base method.
|
|
func (m *MockMutableState) SetHistoryBuilder(hBuilder *historybuilder.HistoryBuilder) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetHistoryBuilder", hBuilder)
|
|
}
|
|
|
|
// SetHistoryBuilder indicates an expected call of SetHistoryBuilder.
|
|
func (mr *MockMutableStateMockRecorder) SetHistoryBuilder(hBuilder any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHistoryBuilder", reflect.TypeOf((*MockMutableState)(nil).SetHistoryBuilder), hBuilder)
|
|
}
|
|
|
|
// SetHistoryTree mocks base method.
|
|
func (m *MockMutableState) SetHistoryTree(executionTimeout, runTimeout *durationpb.Duration, treeID string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetHistoryTree", executionTimeout, runTimeout, treeID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SetHistoryTree indicates an expected call of SetHistoryTree.
|
|
func (mr *MockMutableStateMockRecorder) SetHistoryTree(executionTimeout, runTimeout, treeID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHistoryTree", reflect.TypeOf((*MockMutableState)(nil).SetHistoryTree), executionTimeout, runTimeout, treeID)
|
|
}
|
|
|
|
// SetSpeculativeWorkflowTaskTimeoutTask mocks base method.
|
|
func (m *MockMutableState) SetSpeculativeWorkflowTaskTimeoutTask(task *tasks.WorkflowTaskTimeoutTask) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetSpeculativeWorkflowTaskTimeoutTask", task)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SetSpeculativeWorkflowTaskTimeoutTask indicates an expected call of SetSpeculativeWorkflowTaskTimeoutTask.
|
|
func (mr *MockMutableStateMockRecorder) SetSpeculativeWorkflowTaskTimeoutTask(task any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSpeculativeWorkflowTaskTimeoutTask", reflect.TypeOf((*MockMutableState)(nil).SetSpeculativeWorkflowTaskTimeoutTask), task)
|
|
}
|
|
|
|
// SetStickyTaskQueue mocks base method.
|
|
func (m *MockMutableState) SetStickyTaskQueue(name string, scheduleToStartTimeout *durationpb.Duration) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetStickyTaskQueue", name, scheduleToStartTimeout)
|
|
}
|
|
|
|
// SetStickyTaskQueue indicates an expected call of SetStickyTaskQueue.
|
|
func (mr *MockMutableStateMockRecorder) SetStickyTaskQueue(name, scheduleToStartTimeout any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStickyTaskQueue", reflect.TypeOf((*MockMutableState)(nil).SetStickyTaskQueue), name, scheduleToStartTimeout)
|
|
}
|
|
|
|
// SetSuccessorRunID mocks base method.
|
|
func (m *MockMutableState) SetSuccessorRunID(runID string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetSuccessorRunID", runID)
|
|
}
|
|
|
|
// SetSuccessorRunID indicates an expected call of SetSuccessorRunID.
|
|
func (mr *MockMutableStateMockRecorder) SetSuccessorRunID(runID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSuccessorRunID", reflect.TypeOf((*MockMutableState)(nil).SetSuccessorRunID), runID)
|
|
}
|
|
|
|
// SetUpdateCondition mocks base method.
|
|
func (m *MockMutableState) SetUpdateCondition(arg0, arg1 int64) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetUpdateCondition", arg0, arg1)
|
|
}
|
|
|
|
// SetUpdateCondition indicates an expected call of SetUpdateCondition.
|
|
func (mr *MockMutableStateMockRecorder) SetUpdateCondition(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateCondition", reflect.TypeOf((*MockMutableState)(nil).SetUpdateCondition), arg0, arg1)
|
|
}
|
|
|
|
// SetVersioningRevisionNumber mocks base method.
|
|
func (m *MockMutableState) SetVersioningRevisionNumber(revisionNumber int64) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetVersioningRevisionNumber", revisionNumber)
|
|
}
|
|
|
|
// SetVersioningRevisionNumber indicates an expected call of SetVersioningRevisionNumber.
|
|
func (mr *MockMutableStateMockRecorder) SetVersioningRevisionNumber(revisionNumber any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVersioningRevisionNumber", reflect.TypeOf((*MockMutableState)(nil).SetVersioningRevisionNumber), revisionNumber)
|
|
}
|
|
|
|
// SetWorkflowTaskScheduleToStartTimeoutTask mocks base method.
|
|
func (m *MockMutableState) SetWorkflowTaskScheduleToStartTimeoutTask(task *tasks.WorkflowTaskTimeoutTask) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetWorkflowTaskScheduleToStartTimeoutTask", task)
|
|
}
|
|
|
|
// SetWorkflowTaskScheduleToStartTimeoutTask indicates an expected call of SetWorkflowTaskScheduleToStartTimeoutTask.
|
|
func (mr *MockMutableStateMockRecorder) SetWorkflowTaskScheduleToStartTimeoutTask(task any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWorkflowTaskScheduleToStartTimeoutTask", reflect.TypeOf((*MockMutableState)(nil).SetWorkflowTaskScheduleToStartTimeoutTask), task)
|
|
}
|
|
|
|
// SetWorkflowTaskStartToCloseTimeoutTask mocks base method.
|
|
func (m *MockMutableState) SetWorkflowTaskStartToCloseTimeoutTask(task *tasks.WorkflowTaskTimeoutTask) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetWorkflowTaskStartToCloseTimeoutTask", task)
|
|
}
|
|
|
|
// SetWorkflowTaskStartToCloseTimeoutTask indicates an expected call of SetWorkflowTaskStartToCloseTimeoutTask.
|
|
func (mr *MockMutableStateMockRecorder) SetWorkflowTaskStartToCloseTimeoutTask(task any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWorkflowTaskStartToCloseTimeoutTask", reflect.TypeOf((*MockMutableState)(nil).SetWorkflowTaskStartToCloseTimeoutTask), task)
|
|
}
|
|
|
|
// ShouldResetActivityTimerTaskMask mocks base method.
|
|
func (m *MockMutableState) ShouldResetActivityTimerTaskMask(current, incoming *persistence.ActivityInfo) bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ShouldResetActivityTimerTaskMask", current, incoming)
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// ShouldResetActivityTimerTaskMask indicates an expected call of ShouldResetActivityTimerTaskMask.
|
|
func (mr *MockMutableStateMockRecorder) ShouldResetActivityTimerTaskMask(current, incoming any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShouldResetActivityTimerTaskMask", reflect.TypeOf((*MockMutableState)(nil).ShouldResetActivityTimerTaskMask), current, incoming)
|
|
}
|
|
|
|
// StartDeploymentTransition mocks base method.
|
|
func (m *MockMutableState) StartDeploymentTransition(arg0 *deployment.Deployment, revisionNumber int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StartDeploymentTransition", arg0, revisionNumber)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// StartDeploymentTransition indicates an expected call of StartDeploymentTransition.
|
|
func (mr *MockMutableStateMockRecorder) StartDeploymentTransition(arg0, revisionNumber any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartDeploymentTransition", reflect.TypeOf((*MockMutableState)(nil).StartDeploymentTransition), arg0, revisionNumber)
|
|
}
|
|
|
|
// StartTransaction mocks base method.
|
|
func (m *MockMutableState) StartTransaction(entry *namespace.Namespace) (bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StartTransaction", entry)
|
|
ret0, _ := ret[0].(bool)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// StartTransaction indicates an expected call of StartTransaction.
|
|
func (mr *MockMutableStateMockRecorder) StartTransaction(entry any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartTransaction", reflect.TypeOf((*MockMutableState)(nil).StartTransaction), entry)
|
|
}
|
|
|
|
// TaskQueueScheduleToStartTimeout mocks base method.
|
|
func (m *MockMutableState) TaskQueueScheduleToStartTimeout(name string) (*taskqueue.TaskQueue, *durationpb.Duration) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TaskQueueScheduleToStartTimeout", name)
|
|
ret0, _ := ret[0].(*taskqueue.TaskQueue)
|
|
ret1, _ := ret[1].(*durationpb.Duration)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// TaskQueueScheduleToStartTimeout indicates an expected call of TaskQueueScheduleToStartTimeout.
|
|
func (mr *MockMutableStateMockRecorder) TaskQueueScheduleToStartTimeout(name any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskQueueScheduleToStartTimeout", reflect.TypeOf((*MockMutableState)(nil).TaskQueueScheduleToStartTimeout), name)
|
|
}
|
|
|
|
// UpdateActivity mocks base method.
|
|
func (m *MockMutableState) UpdateActivity(arg0 int64, arg1 ActivityUpdater) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateActivity", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateActivity indicates an expected call of UpdateActivity.
|
|
func (mr *MockMutableStateMockRecorder) UpdateActivity(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateActivity", reflect.TypeOf((*MockMutableState)(nil).UpdateActivity), arg0, arg1)
|
|
}
|
|
|
|
// UpdateActivityInfo mocks base method.
|
|
func (m *MockMutableState) UpdateActivityInfo(arg0 *historyservice.ActivitySyncInfo, arg1 bool) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateActivityInfo", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateActivityInfo indicates an expected call of UpdateActivityInfo.
|
|
func (mr *MockMutableStateMockRecorder) UpdateActivityInfo(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateActivityInfo", reflect.TypeOf((*MockMutableState)(nil).UpdateActivityInfo), arg0, arg1)
|
|
}
|
|
|
|
// UpdateActivityProgress mocks base method.
|
|
func (m *MockMutableState) UpdateActivityProgress(ai *persistence.ActivityInfo, request *workflowservice.RecordActivityTaskHeartbeatRequest) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "UpdateActivityProgress", ai, request)
|
|
}
|
|
|
|
// UpdateActivityProgress indicates an expected call of UpdateActivityProgress.
|
|
func (mr *MockMutableStateMockRecorder) UpdateActivityProgress(ai, request any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateActivityProgress", reflect.TypeOf((*MockMutableState)(nil).UpdateActivityProgress), ai, request)
|
|
}
|
|
|
|
// UpdateActivityTaskStatusWithTimerHeartbeat mocks base method.
|
|
func (m *MockMutableState) UpdateActivityTaskStatusWithTimerHeartbeat(scheduleEventId int64, timerTaskStatus int32, heartbeatTimeoutVisibility *time.Time) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateActivityTaskStatusWithTimerHeartbeat", scheduleEventId, timerTaskStatus, heartbeatTimeoutVisibility)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateActivityTaskStatusWithTimerHeartbeat indicates an expected call of UpdateActivityTaskStatusWithTimerHeartbeat.
|
|
func (mr *MockMutableStateMockRecorder) UpdateActivityTaskStatusWithTimerHeartbeat(scheduleEventId, timerTaskStatus, heartbeatTimeoutVisibility any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateActivityTaskStatusWithTimerHeartbeat", reflect.TypeOf((*MockMutableState)(nil).UpdateActivityTaskStatusWithTimerHeartbeat), scheduleEventId, timerTaskStatus, heartbeatTimeoutVisibility)
|
|
}
|
|
|
|
// UpdateBuildIdAssignment mocks base method.
|
|
func (m *MockMutableState) UpdateBuildIdAssignment(buildId string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateBuildIdAssignment", buildId)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateBuildIdAssignment indicates an expected call of UpdateBuildIdAssignment.
|
|
func (mr *MockMutableStateMockRecorder) UpdateBuildIdAssignment(buildId any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBuildIdAssignment", reflect.TypeOf((*MockMutableState)(nil).UpdateBuildIdAssignment), buildId)
|
|
}
|
|
|
|
// UpdateCurrentVersion mocks base method.
|
|
func (m *MockMutableState) UpdateCurrentVersion(version int64, forceUpdate bool) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateCurrentVersion", version, forceUpdate)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateCurrentVersion indicates an expected call of UpdateCurrentVersion.
|
|
func (mr *MockMutableStateMockRecorder) UpdateCurrentVersion(version, forceUpdate any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCurrentVersion", reflect.TypeOf((*MockMutableState)(nil).UpdateCurrentVersion), version, forceUpdate)
|
|
}
|
|
|
|
// UpdateDuplicatedResource mocks base method.
|
|
func (m *MockMutableState) UpdateDuplicatedResource(resourceDedupKey definition.DeduplicationID) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "UpdateDuplicatedResource", resourceDedupKey)
|
|
}
|
|
|
|
// UpdateDuplicatedResource indicates an expected call of UpdateDuplicatedResource.
|
|
func (mr *MockMutableStateMockRecorder) UpdateDuplicatedResource(resourceDedupKey any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDuplicatedResource", reflect.TypeOf((*MockMutableState)(nil).UpdateDuplicatedResource), resourceDedupKey)
|
|
}
|
|
|
|
// UpdateResetRunID mocks base method.
|
|
func (m *MockMutableState) UpdateResetRunID(runID string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "UpdateResetRunID", runID)
|
|
}
|
|
|
|
// UpdateResetRunID indicates an expected call of UpdateResetRunID.
|
|
func (mr *MockMutableStateMockRecorder) UpdateResetRunID(runID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResetRunID", reflect.TypeOf((*MockMutableState)(nil).UpdateResetRunID), runID)
|
|
}
|
|
|
|
// UpdateUserTimer mocks base method.
|
|
func (m *MockMutableState) UpdateUserTimer(arg0 *persistence.TimerInfo) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateUserTimer", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateUserTimer indicates an expected call of UpdateUserTimer.
|
|
func (mr *MockMutableStateMockRecorder) UpdateUserTimer(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserTimer", reflect.TypeOf((*MockMutableState)(nil).UpdateUserTimer), arg0)
|
|
}
|
|
|
|
// UpdateUserTimerTaskStatus mocks base method.
|
|
func (m *MockMutableState) UpdateUserTimerTaskStatus(timerId string, status int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateUserTimerTaskStatus", timerId, status)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateUserTimerTaskStatus indicates an expected call of UpdateUserTimerTaskStatus.
|
|
func (mr *MockMutableStateMockRecorder) UpdateUserTimerTaskStatus(timerId, status any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserTimerTaskStatus", reflect.TypeOf((*MockMutableState)(nil).UpdateUserTimerTaskStatus), timerId, status)
|
|
}
|
|
|
|
// UpdateWorkflowStateStatus mocks base method.
|
|
func (m *MockMutableState) UpdateWorkflowStateStatus(state enums0.WorkflowExecutionState, status enums.WorkflowExecutionStatus) (bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateWorkflowStateStatus", state, status)
|
|
ret0, _ := ret[0].(bool)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpdateWorkflowStateStatus indicates an expected call of UpdateWorkflowStateStatus.
|
|
func (mr *MockMutableStateMockRecorder) UpdateWorkflowStateStatus(state, status any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkflowStateStatus", reflect.TypeOf((*MockMutableState)(nil).UpdateWorkflowStateStatus), state, status)
|
|
}
|
|
|
|
// VisitUpdates mocks base method.
|
|
func (m *MockMutableState) VisitUpdates(visitor func(string, *persistence.UpdateInfo)) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "VisitUpdates", visitor)
|
|
}
|
|
|
|
// VisitUpdates indicates an expected call of VisitUpdates.
|
|
func (mr *MockMutableStateMockRecorder) VisitUpdates(visitor any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VisitUpdates", reflect.TypeOf((*MockMutableState)(nil).VisitUpdates), visitor)
|
|
}
|