From c131e8df8520cdccdf143042e6cdd3573f56d2bc Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Mon, 23 Sep 2024 12:15:26 -0700 Subject: [PATCH 1/2] Add check for cron workflow using temporal schedule --- service/api/temporal/client.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/service/api/temporal/client.go b/service/api/temporal/client.go index c5fc0322..d5b65d4c 100644 --- a/service/api/temporal/client.go +++ b/service/api/temporal/client.go @@ -45,6 +45,11 @@ func (t *temporalClient) Close() { } func (t *temporalClient) IsWorkflowAlreadyStartedError(err error) bool { + if err.Error() == "schedule with this ID is already registered" { + // there is no type to check, just a string + // https://github.com/temporalio/sdk-go/blob/d10e87118a07b44fd09bf88d39a628f0e6e70c34/internal/error.go#L336 + return true + } return realtemporal.IsWorkflowExecutionAlreadyStartedError(err) } From 76d815854ca3639bdf7d2018c245587c3ec1d47c Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Mon, 23 Sep 2024 15:06:35 -0700 Subject: [PATCH 2/2] Check schedule existence and return error --- .github/workflows/ci-unit-test.yml | 15 + Makefile | 3 + service/api/temporal/client_test.go | 32 + service/api/temporal/data_conveter_mock.go | 130 ++++ .../api/temporal/real_temporal_client_mock.go | 646 ++++++++++++++++++ 5 files changed, 826 insertions(+) create mode 100644 .github/workflows/ci-unit-test.yml create mode 100644 service/api/temporal/client_test.go create mode 100644 service/api/temporal/data_conveter_mock.go create mode 100644 service/api/temporal/real_temporal_client_mock.go diff --git a/.github/workflows/ci-unit-test.yml b/.github/workflows/ci-unit-test.yml new file mode 100644 index 00000000..ceb5356f --- /dev/null +++ b/.github/workflows/ci-unit-test.yml @@ -0,0 +1,15 @@ +name: Unit Test +on: + pull_request: + push: + branches: + - 'main' + +jobs: + tests: + name: "Unit testing" + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - name: "Run unit tests" + run: make unitTests \ No newline at end of file diff --git a/Makefile b/Makefile index 91d5a822..1c384411 100644 --- a/Makefile +++ b/Makefile @@ -200,6 +200,9 @@ stressTestsCadenceNoSearch: stressTestsTemporalNoSearch: $Q go test -v ./integ -repeat=10 -cadence=false -search=false | tee test.log +unitTests: + $Q go test -v ./service/... + help: @# print help first, so it's visible @printf "\033[36m%-20s\033[0m %s\n" 'help' 'Prints a help message showing any specially-commented targets' diff --git a/service/api/temporal/client_test.go b/service/api/temporal/client_test.go new file mode 100644 index 00000000..b4247483 --- /dev/null +++ b/service/api/temporal/client_test.go @@ -0,0 +1,32 @@ +package temporal + +import ( + "errors" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + "go.temporal.io/api/serviceerror" + "testing" +) + +func TestAlreadyStartedErrorForWorkflow(t *testing.T) { + ctrl := gomock.NewController(t) + mockRealTemporalClient := NewMockClient(ctrl) + mockDataConverter := NewMockDataConverter(ctrl) + + client := NewTemporalClient(mockRealTemporalClient, "test-ns", mockDataConverter, false) + + err := &serviceerror.WorkflowExecutionAlreadyStarted{} + assert.Equal(t, true, client.IsWorkflowAlreadyStartedError(err)) +} + +func TestAlreadyStartedErrorForCronWorkflow(t *testing.T) { + ctrl := gomock.NewController(t) + mockRealTemporalClient := NewMockClient(ctrl) + mockDataConverter := NewMockDataConverter(ctrl) + + client := NewTemporalClient(mockRealTemporalClient, "test-ns", mockDataConverter, false) + + err := errors.New("schedule with this ID is already registered") + + assert.Equal(t, true, client.IsWorkflowAlreadyStartedError(err)) +} diff --git a/service/api/temporal/data_conveter_mock.go b/service/api/temporal/data_conveter_mock.go new file mode 100644 index 00000000..7ccd1b29 --- /dev/null +++ b/service/api/temporal/data_conveter_mock.go @@ -0,0 +1,130 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: /Users/qlong/indeed/temporoio/sdk-go/converter/data_converter.go + +// Package temporal is a generated GoMock package. +package temporal + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + common "go.temporal.io/api/common/v1" +) + +// MockDataConverter is a mock of DataConverter interface. +type MockDataConverter struct { + ctrl *gomock.Controller + recorder *MockDataConverterMockRecorder +} + +// MockDataConverterMockRecorder is the mock recorder for MockDataConverter. +type MockDataConverterMockRecorder struct { + mock *MockDataConverter +} + +// NewMockDataConverter creates a new mock instance. +func NewMockDataConverter(ctrl *gomock.Controller) *MockDataConverter { + mock := &MockDataConverter{ctrl: ctrl} + mock.recorder = &MockDataConverterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockDataConverter) EXPECT() *MockDataConverterMockRecorder { + return m.recorder +} + +// FromPayload mocks base method. +func (m *MockDataConverter) FromPayload(payload *common.Payload, valuePtr interface{}) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FromPayload", payload, valuePtr) + ret0, _ := ret[0].(error) + return ret0 +} + +// FromPayload indicates an expected call of FromPayload. +func (mr *MockDataConverterMockRecorder) FromPayload(payload, valuePtr interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FromPayload", reflect.TypeOf((*MockDataConverter)(nil).FromPayload), payload, valuePtr) +} + +// FromPayloads mocks base method. +func (m *MockDataConverter) FromPayloads(payloads *common.Payloads, valuePtrs ...interface{}) error { + m.ctrl.T.Helper() + varargs := []interface{}{payloads} + for _, a := range valuePtrs { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FromPayloads", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// FromPayloads indicates an expected call of FromPayloads. +func (mr *MockDataConverterMockRecorder) FromPayloads(payloads interface{}, valuePtrs ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{payloads}, valuePtrs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FromPayloads", reflect.TypeOf((*MockDataConverter)(nil).FromPayloads), varargs...) +} + +// ToPayload mocks base method. +func (m *MockDataConverter) ToPayload(value interface{}) (*common.Payload, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ToPayload", value) + ret0, _ := ret[0].(*common.Payload) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ToPayload indicates an expected call of ToPayload. +func (mr *MockDataConverterMockRecorder) ToPayload(value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToPayload", reflect.TypeOf((*MockDataConverter)(nil).ToPayload), value) +} + +// ToPayloads mocks base method. +func (m *MockDataConverter) ToPayloads(value ...interface{}) (*common.Payloads, error) { + m.ctrl.T.Helper() + varargs := []interface{}{} + for _, a := range value { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ToPayloads", varargs...) + ret0, _ := ret[0].(*common.Payloads) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ToPayloads indicates an expected call of ToPayloads. +func (mr *MockDataConverterMockRecorder) ToPayloads(value ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToPayloads", reflect.TypeOf((*MockDataConverter)(nil).ToPayloads), value...) +} + +// ToString mocks base method. +func (m *MockDataConverter) ToString(input *common.Payload) string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ToString", input) + ret0, _ := ret[0].(string) + return ret0 +} + +// ToString indicates an expected call of ToString. +func (mr *MockDataConverterMockRecorder) ToString(input interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToString", reflect.TypeOf((*MockDataConverter)(nil).ToString), input) +} + +// ToStrings mocks base method. +func (m *MockDataConverter) ToStrings(input *common.Payloads) []string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ToStrings", input) + ret0, _ := ret[0].([]string) + return ret0 +} + +// ToStrings indicates an expected call of ToStrings. +func (mr *MockDataConverterMockRecorder) ToStrings(input interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToStrings", reflect.TypeOf((*MockDataConverter)(nil).ToStrings), input) +} diff --git a/service/api/temporal/real_temporal_client_mock.go b/service/api/temporal/real_temporal_client_mock.go new file mode 100644 index 00000000..37d4dcc5 --- /dev/null +++ b/service/api/temporal/real_temporal_client_mock.go @@ -0,0 +1,646 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: /Users/qlong/indeed/temporoio/sdk-go/client/client.go + +// Package temporal is a generated GoMock package. +package temporal + +import ( + context "context" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + enums "go.temporal.io/api/enums/v1" + operatorservice "go.temporal.io/api/operatorservice/v1" + workflowservice "go.temporal.io/api/workflowservice/v1" + client "go.temporal.io/sdk/client" + converter "go.temporal.io/sdk/converter" +) + +// MockClient is a mock of Client interface. +type MockClient struct { + ctrl *gomock.Controller + recorder *MockClientMockRecorder +} + +// MockClientMockRecorder is the mock recorder for MockClient. +type MockClientMockRecorder struct { + mock *MockClient +} + +// NewMockClient creates a new mock instance. +func NewMockClient(ctrl *gomock.Controller) *MockClient { + mock := &MockClient{ctrl: ctrl} + mock.recorder = &MockClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockClient) EXPECT() *MockClientMockRecorder { + return m.recorder +} + +// CancelWorkflow mocks base method. +func (m *MockClient) CancelWorkflow(ctx context.Context, workflowID, runID string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelWorkflow", ctx, workflowID, runID) + ret0, _ := ret[0].(error) + return ret0 +} + +// CancelWorkflow indicates an expected call of CancelWorkflow. +func (mr *MockClientMockRecorder) CancelWorkflow(ctx, workflowID, runID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelWorkflow", reflect.TypeOf((*MockClient)(nil).CancelWorkflow), ctx, workflowID, runID) +} + +// CheckHealth mocks base method. +func (m *MockClient) CheckHealth(ctx context.Context, request *client.CheckHealthRequest) (*client.CheckHealthResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CheckHealth", ctx, request) + ret0, _ := ret[0].(*client.CheckHealthResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CheckHealth indicates an expected call of CheckHealth. +func (mr *MockClientMockRecorder) CheckHealth(ctx, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckHealth", reflect.TypeOf((*MockClient)(nil).CheckHealth), ctx, request) +} + +// Close mocks base method. +func (m *MockClient) Close() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Close") +} + +// Close indicates an expected call of Close. +func (mr *MockClientMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClient)(nil).Close)) +} + +// CompleteActivity mocks base method. +func (m *MockClient) CompleteActivity(ctx context.Context, taskToken []byte, result interface{}, err error) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CompleteActivity", ctx, taskToken, result, err) + ret0, _ := ret[0].(error) + return ret0 +} + +// CompleteActivity indicates an expected call of CompleteActivity. +func (mr *MockClientMockRecorder) CompleteActivity(ctx, taskToken, result, err interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteActivity", reflect.TypeOf((*MockClient)(nil).CompleteActivity), ctx, taskToken, result, err) +} + +// CompleteActivityByID mocks base method. +func (m *MockClient) CompleteActivityByID(ctx context.Context, namespace, workflowID, runID, activityID string, result interface{}, err error) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CompleteActivityByID", ctx, namespace, workflowID, runID, activityID, result, err) + ret0, _ := ret[0].(error) + return ret0 +} + +// CompleteActivityByID indicates an expected call of CompleteActivityByID. +func (mr *MockClientMockRecorder) CompleteActivityByID(ctx, namespace, workflowID, runID, activityID, result, err interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteActivityByID", reflect.TypeOf((*MockClient)(nil).CompleteActivityByID), ctx, namespace, workflowID, runID, activityID, result, err) +} + +// CountWorkflow mocks base method. +func (m *MockClient) CountWorkflow(ctx context.Context, request *workflowservice.CountWorkflowExecutionsRequest) (*workflowservice.CountWorkflowExecutionsResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CountWorkflow", ctx, request) + ret0, _ := ret[0].(*workflowservice.CountWorkflowExecutionsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CountWorkflow indicates an expected call of CountWorkflow. +func (mr *MockClientMockRecorder) CountWorkflow(ctx, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountWorkflow", reflect.TypeOf((*MockClient)(nil).CountWorkflow), ctx, request) +} + +// DescribeTaskQueue mocks base method. +func (m *MockClient) DescribeTaskQueue(ctx context.Context, taskqueue string, taskqueueType enums.TaskQueueType) (*workflowservice.DescribeTaskQueueResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTaskQueue", ctx, taskqueue, taskqueueType) + ret0, _ := ret[0].(*workflowservice.DescribeTaskQueueResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTaskQueue indicates an expected call of DescribeTaskQueue. +func (mr *MockClientMockRecorder) DescribeTaskQueue(ctx, taskqueue, taskqueueType interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTaskQueue", reflect.TypeOf((*MockClient)(nil).DescribeTaskQueue), ctx, taskqueue, taskqueueType) +} + +// DescribeWorkflowExecution mocks base method. +func (m *MockClient) DescribeWorkflowExecution(ctx context.Context, workflowID, runID string) (*workflowservice.DescribeWorkflowExecutionResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeWorkflowExecution", ctx, workflowID, runID) + ret0, _ := ret[0].(*workflowservice.DescribeWorkflowExecutionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeWorkflowExecution indicates an expected call of DescribeWorkflowExecution. +func (mr *MockClientMockRecorder) DescribeWorkflowExecution(ctx, workflowID, runID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeWorkflowExecution", reflect.TypeOf((*MockClient)(nil).DescribeWorkflowExecution), ctx, workflowID, runID) +} + +// ExecuteWorkflow mocks base method. +func (m *MockClient) ExecuteWorkflow(ctx context.Context, options client.StartWorkflowOptions, workflow interface{}, args ...interface{}) (client.WorkflowRun, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, options, workflow} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ExecuteWorkflow", varargs...) + ret0, _ := ret[0].(client.WorkflowRun) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ExecuteWorkflow indicates an expected call of ExecuteWorkflow. +func (mr *MockClientMockRecorder) ExecuteWorkflow(ctx, options, workflow interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, options, workflow}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteWorkflow", reflect.TypeOf((*MockClient)(nil).ExecuteWorkflow), varargs...) +} + +// GetSearchAttributes mocks base method. +func (m *MockClient) GetSearchAttributes(ctx context.Context) (*workflowservice.GetSearchAttributesResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSearchAttributes", ctx) + ret0, _ := ret[0].(*workflowservice.GetSearchAttributesResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSearchAttributes indicates an expected call of GetSearchAttributes. +func (mr *MockClientMockRecorder) GetSearchAttributes(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSearchAttributes", reflect.TypeOf((*MockClient)(nil).GetSearchAttributes), ctx) +} + +// GetWorkerBuildIdCompatibility mocks base method. +func (m *MockClient) GetWorkerBuildIdCompatibility(ctx context.Context, options *client.GetWorkerBuildIdCompatibilityOptions) (*client.WorkerBuildIDVersionSets, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetWorkerBuildIdCompatibility", ctx, options) + ret0, _ := ret[0].(*client.WorkerBuildIDVersionSets) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetWorkerBuildIdCompatibility indicates an expected call of GetWorkerBuildIdCompatibility. +func (mr *MockClientMockRecorder) GetWorkerBuildIdCompatibility(ctx, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkerBuildIdCompatibility", reflect.TypeOf((*MockClient)(nil).GetWorkerBuildIdCompatibility), ctx, options) +} + +// GetWorkerTaskReachability mocks base method. +func (m *MockClient) GetWorkerTaskReachability(ctx context.Context, options *client.GetWorkerTaskReachabilityOptions) (*client.WorkerTaskReachability, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetWorkerTaskReachability", ctx, options) + ret0, _ := ret[0].(*client.WorkerTaskReachability) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetWorkerTaskReachability indicates an expected call of GetWorkerTaskReachability. +func (mr *MockClientMockRecorder) GetWorkerTaskReachability(ctx, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkerTaskReachability", reflect.TypeOf((*MockClient)(nil).GetWorkerTaskReachability), ctx, options) +} + +// GetWorkflow mocks base method. +func (m *MockClient) GetWorkflow(ctx context.Context, workflowID, runID string) client.WorkflowRun { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetWorkflow", ctx, workflowID, runID) + ret0, _ := ret[0].(client.WorkflowRun) + return ret0 +} + +// GetWorkflow indicates an expected call of GetWorkflow. +func (mr *MockClientMockRecorder) GetWorkflow(ctx, workflowID, runID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflow", reflect.TypeOf((*MockClient)(nil).GetWorkflow), ctx, workflowID, runID) +} + +// GetWorkflowHistory mocks base method. +func (m *MockClient) GetWorkflowHistory(ctx context.Context, workflowID, runID string, isLongPoll bool, filterType enums.HistoryEventFilterType) client.HistoryEventIterator { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetWorkflowHistory", ctx, workflowID, runID, isLongPoll, filterType) + ret0, _ := ret[0].(client.HistoryEventIterator) + return ret0 +} + +// GetWorkflowHistory indicates an expected call of GetWorkflowHistory. +func (mr *MockClientMockRecorder) GetWorkflowHistory(ctx, workflowID, runID, isLongPoll, filterType interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowHistory", reflect.TypeOf((*MockClient)(nil).GetWorkflowHistory), ctx, workflowID, runID, isLongPoll, filterType) +} + +// GetWorkflowUpdateHandle mocks base method. +func (m *MockClient) GetWorkflowUpdateHandle(ref client.GetWorkflowUpdateHandleOptions) client.WorkflowUpdateHandle { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetWorkflowUpdateHandle", ref) + ret0, _ := ret[0].(client.WorkflowUpdateHandle) + return ret0 +} + +// GetWorkflowUpdateHandle indicates an expected call of GetWorkflowUpdateHandle. +func (mr *MockClientMockRecorder) GetWorkflowUpdateHandle(ref interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowUpdateHandle", reflect.TypeOf((*MockClient)(nil).GetWorkflowUpdateHandle), ref) +} + +// ListArchivedWorkflow mocks base method. +func (m *MockClient) ListArchivedWorkflow(ctx context.Context, request *workflowservice.ListArchivedWorkflowExecutionsRequest) (*workflowservice.ListArchivedWorkflowExecutionsResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListArchivedWorkflow", ctx, request) + ret0, _ := ret[0].(*workflowservice.ListArchivedWorkflowExecutionsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListArchivedWorkflow indicates an expected call of ListArchivedWorkflow. +func (mr *MockClientMockRecorder) ListArchivedWorkflow(ctx, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListArchivedWorkflow", reflect.TypeOf((*MockClient)(nil).ListArchivedWorkflow), ctx, request) +} + +// ListClosedWorkflow mocks base method. +func (m *MockClient) ListClosedWorkflow(ctx context.Context, request *workflowservice.ListClosedWorkflowExecutionsRequest) (*workflowservice.ListClosedWorkflowExecutionsResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListClosedWorkflow", ctx, request) + ret0, _ := ret[0].(*workflowservice.ListClosedWorkflowExecutionsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListClosedWorkflow indicates an expected call of ListClosedWorkflow. +func (mr *MockClientMockRecorder) ListClosedWorkflow(ctx, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClosedWorkflow", reflect.TypeOf((*MockClient)(nil).ListClosedWorkflow), ctx, request) +} + +// ListOpenWorkflow mocks base method. +func (m *MockClient) ListOpenWorkflow(ctx context.Context, request *workflowservice.ListOpenWorkflowExecutionsRequest) (*workflowservice.ListOpenWorkflowExecutionsResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListOpenWorkflow", ctx, request) + ret0, _ := ret[0].(*workflowservice.ListOpenWorkflowExecutionsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListOpenWorkflow indicates an expected call of ListOpenWorkflow. +func (mr *MockClientMockRecorder) ListOpenWorkflow(ctx, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpenWorkflow", reflect.TypeOf((*MockClient)(nil).ListOpenWorkflow), ctx, request) +} + +// ListWorkflow mocks base method. +func (m *MockClient) ListWorkflow(ctx context.Context, request *workflowservice.ListWorkflowExecutionsRequest) (*workflowservice.ListWorkflowExecutionsResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListWorkflow", ctx, request) + ret0, _ := ret[0].(*workflowservice.ListWorkflowExecutionsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListWorkflow indicates an expected call of ListWorkflow. +func (mr *MockClientMockRecorder) ListWorkflow(ctx, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkflow", reflect.TypeOf((*MockClient)(nil).ListWorkflow), ctx, request) +} + +// OperatorService mocks base method. +func (m *MockClient) OperatorService() operatorservice.OperatorServiceClient { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OperatorService") + ret0, _ := ret[0].(operatorservice.OperatorServiceClient) + return ret0 +} + +// OperatorService indicates an expected call of OperatorService. +func (mr *MockClientMockRecorder) OperatorService() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OperatorService", reflect.TypeOf((*MockClient)(nil).OperatorService)) +} + +// QueryWorkflow mocks base method. +func (m *MockClient) QueryWorkflow(ctx context.Context, workflowID, runID, queryType string, args ...interface{}) (converter.EncodedValue, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, workflowID, runID, queryType} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "QueryWorkflow", varargs...) + ret0, _ := ret[0].(converter.EncodedValue) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryWorkflow indicates an expected call of QueryWorkflow. +func (mr *MockClientMockRecorder) QueryWorkflow(ctx, workflowID, runID, queryType interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, workflowID, runID, queryType}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryWorkflow", reflect.TypeOf((*MockClient)(nil).QueryWorkflow), varargs...) +} + +// QueryWorkflowWithOptions mocks base method. +func (m *MockClient) QueryWorkflowWithOptions(ctx context.Context, request *client.QueryWorkflowWithOptionsRequest) (*client.QueryWorkflowWithOptionsResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryWorkflowWithOptions", ctx, request) + ret0, _ := ret[0].(*client.QueryWorkflowWithOptionsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryWorkflowWithOptions indicates an expected call of QueryWorkflowWithOptions. +func (mr *MockClientMockRecorder) QueryWorkflowWithOptions(ctx, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryWorkflowWithOptions", reflect.TypeOf((*MockClient)(nil).QueryWorkflowWithOptions), ctx, request) +} + +// RecordActivityHeartbeat mocks base method. +func (m *MockClient) RecordActivityHeartbeat(ctx context.Context, taskToken []byte, details ...interface{}) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, taskToken} + for _, a := range details { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RecordActivityHeartbeat", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// RecordActivityHeartbeat indicates an expected call of RecordActivityHeartbeat. +func (mr *MockClientMockRecorder) RecordActivityHeartbeat(ctx, taskToken interface{}, details ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, taskToken}, details...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordActivityHeartbeat", reflect.TypeOf((*MockClient)(nil).RecordActivityHeartbeat), varargs...) +} + +// RecordActivityHeartbeatByID mocks base method. +func (m *MockClient) RecordActivityHeartbeatByID(ctx context.Context, namespace, workflowID, runID, activityID string, details ...interface{}) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, namespace, workflowID, runID, activityID} + for _, a := range details { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RecordActivityHeartbeatByID", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// RecordActivityHeartbeatByID indicates an expected call of RecordActivityHeartbeatByID. +func (mr *MockClientMockRecorder) RecordActivityHeartbeatByID(ctx, namespace, workflowID, runID, activityID interface{}, details ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, namespace, workflowID, runID, activityID}, details...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordActivityHeartbeatByID", reflect.TypeOf((*MockClient)(nil).RecordActivityHeartbeatByID), varargs...) +} + +// ResetWorkflowExecution mocks base method. +func (m *MockClient) ResetWorkflowExecution(ctx context.Context, request *workflowservice.ResetWorkflowExecutionRequest) (*workflowservice.ResetWorkflowExecutionResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetWorkflowExecution", ctx, request) + ret0, _ := ret[0].(*workflowservice.ResetWorkflowExecutionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetWorkflowExecution indicates an expected call of ResetWorkflowExecution. +func (mr *MockClientMockRecorder) ResetWorkflowExecution(ctx, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetWorkflowExecution", reflect.TypeOf((*MockClient)(nil).ResetWorkflowExecution), ctx, request) +} + +// ScanWorkflow mocks base method. +func (m *MockClient) ScanWorkflow(ctx context.Context, request *workflowservice.ScanWorkflowExecutionsRequest) (*workflowservice.ScanWorkflowExecutionsResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScanWorkflow", ctx, request) + ret0, _ := ret[0].(*workflowservice.ScanWorkflowExecutionsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ScanWorkflow indicates an expected call of ScanWorkflow. +func (mr *MockClientMockRecorder) ScanWorkflow(ctx, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanWorkflow", reflect.TypeOf((*MockClient)(nil).ScanWorkflow), ctx, request) +} + +// ScheduleClient mocks base method. +func (m *MockClient) ScheduleClient() client.ScheduleClient { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScheduleClient") + ret0, _ := ret[0].(client.ScheduleClient) + return ret0 +} + +// ScheduleClient indicates an expected call of ScheduleClient. +func (mr *MockClientMockRecorder) ScheduleClient() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScheduleClient", reflect.TypeOf((*MockClient)(nil).ScheduleClient)) +} + +// SignalWithStartWorkflow mocks base method. +func (m *MockClient) SignalWithStartWorkflow(ctx context.Context, workflowID, signalName string, signalArg interface{}, options client.StartWorkflowOptions, workflow interface{}, workflowArgs ...interface{}) (client.WorkflowRun, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, workflowID, signalName, signalArg, options, workflow} + for _, a := range workflowArgs { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SignalWithStartWorkflow", varargs...) + ret0, _ := ret[0].(client.WorkflowRun) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SignalWithStartWorkflow indicates an expected call of SignalWithStartWorkflow. +func (mr *MockClientMockRecorder) SignalWithStartWorkflow(ctx, workflowID, signalName, signalArg, options, workflow interface{}, workflowArgs ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, workflowID, signalName, signalArg, options, workflow}, workflowArgs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignalWithStartWorkflow", reflect.TypeOf((*MockClient)(nil).SignalWithStartWorkflow), varargs...) +} + +// SignalWorkflow mocks base method. +func (m *MockClient) SignalWorkflow(ctx context.Context, workflowID, runID, signalName string, arg interface{}) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SignalWorkflow", ctx, workflowID, runID, signalName, arg) + ret0, _ := ret[0].(error) + return ret0 +} + +// SignalWorkflow indicates an expected call of SignalWorkflow. +func (mr *MockClientMockRecorder) SignalWorkflow(ctx, workflowID, runID, signalName, arg interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignalWorkflow", reflect.TypeOf((*MockClient)(nil).SignalWorkflow), ctx, workflowID, runID, signalName, arg) +} + +// TerminateWorkflow mocks base method. +func (m *MockClient) TerminateWorkflow(ctx context.Context, workflowID, runID, reason string, details ...interface{}) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, workflowID, runID, reason} + for _, a := range details { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TerminateWorkflow", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// TerminateWorkflow indicates an expected call of TerminateWorkflow. +func (mr *MockClientMockRecorder) TerminateWorkflow(ctx, workflowID, runID, reason interface{}, details ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, workflowID, runID, reason}, details...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateWorkflow", reflect.TypeOf((*MockClient)(nil).TerminateWorkflow), varargs...) +} + +// UpdateWorkerBuildIdCompatibility mocks base method. +func (m *MockClient) UpdateWorkerBuildIdCompatibility(ctx context.Context, options *client.UpdateWorkerBuildIdCompatibilityOptions) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateWorkerBuildIdCompatibility", ctx, options) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateWorkerBuildIdCompatibility indicates an expected call of UpdateWorkerBuildIdCompatibility. +func (mr *MockClientMockRecorder) UpdateWorkerBuildIdCompatibility(ctx, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkerBuildIdCompatibility", reflect.TypeOf((*MockClient)(nil).UpdateWorkerBuildIdCompatibility), ctx, options) +} + +// UpdateWorkflow mocks base method. +func (m *MockClient) UpdateWorkflow(ctx context.Context, workflowID, workflowRunID, updateName string, args ...interface{}) (client.WorkflowUpdateHandle, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, workflowID, workflowRunID, updateName} + for _, a := range args { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateWorkflow", varargs...) + ret0, _ := ret[0].(client.WorkflowUpdateHandle) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateWorkflow indicates an expected call of UpdateWorkflow. +func (mr *MockClientMockRecorder) UpdateWorkflow(ctx, workflowID, workflowRunID, updateName interface{}, args ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, workflowID, workflowRunID, updateName}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkflow", reflect.TypeOf((*MockClient)(nil).UpdateWorkflow), varargs...) +} + +// UpdateWorkflowWithOptions mocks base method. +func (m *MockClient) UpdateWorkflowWithOptions(ctx context.Context, request *client.UpdateWorkflowWithOptionsRequest) (client.WorkflowUpdateHandle, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateWorkflowWithOptions", ctx, request) + ret0, _ := ret[0].(client.WorkflowUpdateHandle) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateWorkflowWithOptions indicates an expected call of UpdateWorkflowWithOptions. +func (mr *MockClientMockRecorder) UpdateWorkflowWithOptions(ctx, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkflowWithOptions", reflect.TypeOf((*MockClient)(nil).UpdateWorkflowWithOptions), ctx, request) +} + +// WorkflowService mocks base method. +func (m *MockClient) WorkflowService() workflowservice.WorkflowServiceClient { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WorkflowService") + ret0, _ := ret[0].(workflowservice.WorkflowServiceClient) + return ret0 +} + +// WorkflowService indicates an expected call of WorkflowService. +func (mr *MockClientMockRecorder) WorkflowService() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkflowService", reflect.TypeOf((*MockClient)(nil).WorkflowService)) +} + +// MockNamespaceClient is a mock of NamespaceClient interface. +type MockNamespaceClient struct { + ctrl *gomock.Controller + recorder *MockNamespaceClientMockRecorder +} + +// MockNamespaceClientMockRecorder is the mock recorder for MockNamespaceClient. +type MockNamespaceClientMockRecorder struct { + mock *MockNamespaceClient +} + +// NewMockNamespaceClient creates a new mock instance. +func NewMockNamespaceClient(ctrl *gomock.Controller) *MockNamespaceClient { + mock := &MockNamespaceClient{ctrl: ctrl} + mock.recorder = &MockNamespaceClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockNamespaceClient) EXPECT() *MockNamespaceClientMockRecorder { + return m.recorder +} + +// Close mocks base method. +func (m *MockNamespaceClient) Close() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Close") +} + +// Close indicates an expected call of Close. +func (mr *MockNamespaceClientMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockNamespaceClient)(nil).Close)) +} + +// Describe mocks base method. +func (m *MockNamespaceClient) Describe(ctx context.Context, name string) (*workflowservice.DescribeNamespaceResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Describe", ctx, name) + ret0, _ := ret[0].(*workflowservice.DescribeNamespaceResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Describe indicates an expected call of Describe. +func (mr *MockNamespaceClientMockRecorder) Describe(ctx, name interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Describe", reflect.TypeOf((*MockNamespaceClient)(nil).Describe), ctx, name) +} + +// Register mocks base method. +func (m *MockNamespaceClient) Register(ctx context.Context, request *workflowservice.RegisterNamespaceRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Register", ctx, request) + ret0, _ := ret[0].(error) + return ret0 +} + +// Register indicates an expected call of Register. +func (mr *MockNamespaceClientMockRecorder) Register(ctx, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Register", reflect.TypeOf((*MockNamespaceClient)(nil).Register), ctx, request) +} + +// Update mocks base method. +func (m *MockNamespaceClient) Update(ctx context.Context, request *workflowservice.UpdateNamespaceRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Update", ctx, request) + ret0, _ := ret[0].(error) + return ret0 +} + +// Update indicates an expected call of Update. +func (mr *MockNamespaceClientMockRecorder) Update(ctx, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockNamespaceClient)(nil).Update), ctx, request) +}