mirror of
https://github.com/rocky-linux/peridot.git
synced 2024-11-01 04:41:22 +00:00
1413 lines
72 KiB
Go
1413 lines
72 KiB
Go
// The MIT License
|
|
//
|
|
// Copyright (c) 2020 Temporal Technologies Inc. All rights reserved.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
// THE SOFTWARE.
|
|
|
|
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: workflowservice/v1/service.pb.go
|
|
|
|
// Package workflowservicemock is a generated GoMock package.
|
|
package workflowservicemock
|
|
|
|
import (
|
|
context "context"
|
|
reflect "reflect"
|
|
|
|
gomock "github.com/golang/mock/gomock"
|
|
workflowservice "go.temporal.io/api/workflowservice/v1"
|
|
grpc "google.golang.org/grpc"
|
|
)
|
|
|
|
// MockWorkflowServiceClient is a mock of WorkflowServiceClient interface.
|
|
type MockWorkflowServiceClient struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockWorkflowServiceClientMockRecorder
|
|
}
|
|
|
|
// MockWorkflowServiceClientMockRecorder is the mock recorder for MockWorkflowServiceClient.
|
|
type MockWorkflowServiceClientMockRecorder struct {
|
|
mock *MockWorkflowServiceClient
|
|
}
|
|
|
|
// NewMockWorkflowServiceClient creates a new mock instance.
|
|
func NewMockWorkflowServiceClient(ctrl *gomock.Controller) *MockWorkflowServiceClient {
|
|
mock := &MockWorkflowServiceClient{ctrl: ctrl}
|
|
mock.recorder = &MockWorkflowServiceClientMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockWorkflowServiceClient) EXPECT() *MockWorkflowServiceClientMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// CountWorkflowExecutions mocks base method.
|
|
func (m *MockWorkflowServiceClient) CountWorkflowExecutions(ctx context.Context, in *workflowservice.CountWorkflowExecutionsRequest, opts ...grpc.CallOption) (*workflowservice.CountWorkflowExecutionsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "CountWorkflowExecutions", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.CountWorkflowExecutionsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CountWorkflowExecutions indicates an expected call of CountWorkflowExecutions.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) CountWorkflowExecutions(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountWorkflowExecutions", reflect.TypeOf((*MockWorkflowServiceClient)(nil).CountWorkflowExecutions), varargs...)
|
|
}
|
|
|
|
// DeprecateNamespace mocks base method.
|
|
func (m *MockWorkflowServiceClient) DeprecateNamespace(ctx context.Context, in *workflowservice.DeprecateNamespaceRequest, opts ...grpc.CallOption) (*workflowservice.DeprecateNamespaceResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "DeprecateNamespace", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.DeprecateNamespaceResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DeprecateNamespace indicates an expected call of DeprecateNamespace.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) DeprecateNamespace(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprecateNamespace", reflect.TypeOf((*MockWorkflowServiceClient)(nil).DeprecateNamespace), varargs...)
|
|
}
|
|
|
|
// DescribeNamespace mocks base method.
|
|
func (m *MockWorkflowServiceClient) DescribeNamespace(ctx context.Context, in *workflowservice.DescribeNamespaceRequest, opts ...grpc.CallOption) (*workflowservice.DescribeNamespaceResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "DescribeNamespace", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.DescribeNamespaceResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DescribeNamespace indicates an expected call of DescribeNamespace.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) DescribeNamespace(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNamespace", reflect.TypeOf((*MockWorkflowServiceClient)(nil).DescribeNamespace), varargs...)
|
|
}
|
|
|
|
// DescribeTaskQueue mocks base method.
|
|
func (m *MockWorkflowServiceClient) DescribeTaskQueue(ctx context.Context, in *workflowservice.DescribeTaskQueueRequest, opts ...grpc.CallOption) (*workflowservice.DescribeTaskQueueResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "DescribeTaskQueue", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.DescribeTaskQueueResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DescribeTaskQueue indicates an expected call of DescribeTaskQueue.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) DescribeTaskQueue(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTaskQueue", reflect.TypeOf((*MockWorkflowServiceClient)(nil).DescribeTaskQueue), varargs...)
|
|
}
|
|
|
|
// DescribeWorkflowExecution mocks base method.
|
|
func (m *MockWorkflowServiceClient) DescribeWorkflowExecution(ctx context.Context, in *workflowservice.DescribeWorkflowExecutionRequest, opts ...grpc.CallOption) (*workflowservice.DescribeWorkflowExecutionResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "DescribeWorkflowExecution", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.DescribeWorkflowExecutionResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DescribeWorkflowExecution indicates an expected call of DescribeWorkflowExecution.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) DescribeWorkflowExecution(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).DescribeWorkflowExecution), varargs...)
|
|
}
|
|
|
|
// GetClusterInfo mocks base method.
|
|
func (m *MockWorkflowServiceClient) GetClusterInfo(ctx context.Context, in *workflowservice.GetClusterInfoRequest, opts ...grpc.CallOption) (*workflowservice.GetClusterInfoResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "GetClusterInfo", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.GetClusterInfoResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetClusterInfo indicates an expected call of GetClusterInfo.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) GetClusterInfo(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterInfo", reflect.TypeOf((*MockWorkflowServiceClient)(nil).GetClusterInfo), varargs...)
|
|
}
|
|
|
|
// GetSearchAttributes mocks base method.
|
|
func (m *MockWorkflowServiceClient) GetSearchAttributes(ctx context.Context, in *workflowservice.GetSearchAttributesRequest, opts ...grpc.CallOption) (*workflowservice.GetSearchAttributesResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "GetSearchAttributes", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.GetSearchAttributesResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetSearchAttributes indicates an expected call of GetSearchAttributes.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) GetSearchAttributes(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSearchAttributes", reflect.TypeOf((*MockWorkflowServiceClient)(nil).GetSearchAttributes), varargs...)
|
|
}
|
|
|
|
// GetWorkflowExecutionHistory mocks base method.
|
|
func (m *MockWorkflowServiceClient) GetWorkflowExecutionHistory(ctx context.Context, in *workflowservice.GetWorkflowExecutionHistoryRequest, opts ...grpc.CallOption) (*workflowservice.GetWorkflowExecutionHistoryResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "GetWorkflowExecutionHistory", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.GetWorkflowExecutionHistoryResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetWorkflowExecutionHistory indicates an expected call of GetWorkflowExecutionHistory.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) GetWorkflowExecutionHistory(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowExecutionHistory", reflect.TypeOf((*MockWorkflowServiceClient)(nil).GetWorkflowExecutionHistory), varargs...)
|
|
}
|
|
|
|
// ListArchivedWorkflowExecutions mocks base method.
|
|
func (m *MockWorkflowServiceClient) ListArchivedWorkflowExecutions(ctx context.Context, in *workflowservice.ListArchivedWorkflowExecutionsRequest, opts ...grpc.CallOption) (*workflowservice.ListArchivedWorkflowExecutionsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "ListArchivedWorkflowExecutions", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.ListArchivedWorkflowExecutionsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListArchivedWorkflowExecutions indicates an expected call of ListArchivedWorkflowExecutions.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) ListArchivedWorkflowExecutions(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListArchivedWorkflowExecutions", reflect.TypeOf((*MockWorkflowServiceClient)(nil).ListArchivedWorkflowExecutions), varargs...)
|
|
}
|
|
|
|
// ListClosedWorkflowExecutions mocks base method.
|
|
func (m *MockWorkflowServiceClient) ListClosedWorkflowExecutions(ctx context.Context, in *workflowservice.ListClosedWorkflowExecutionsRequest, opts ...grpc.CallOption) (*workflowservice.ListClosedWorkflowExecutionsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "ListClosedWorkflowExecutions", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.ListClosedWorkflowExecutionsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListClosedWorkflowExecutions indicates an expected call of ListClosedWorkflowExecutions.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) ListClosedWorkflowExecutions(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClosedWorkflowExecutions", reflect.TypeOf((*MockWorkflowServiceClient)(nil).ListClosedWorkflowExecutions), varargs...)
|
|
}
|
|
|
|
// ListNamespaces mocks base method.
|
|
func (m *MockWorkflowServiceClient) ListNamespaces(ctx context.Context, in *workflowservice.ListNamespacesRequest, opts ...grpc.CallOption) (*workflowservice.ListNamespacesResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "ListNamespaces", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.ListNamespacesResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListNamespaces indicates an expected call of ListNamespaces.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) ListNamespaces(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNamespaces", reflect.TypeOf((*MockWorkflowServiceClient)(nil).ListNamespaces), varargs...)
|
|
}
|
|
|
|
// ListOpenWorkflowExecutions mocks base method.
|
|
func (m *MockWorkflowServiceClient) ListOpenWorkflowExecutions(ctx context.Context, in *workflowservice.ListOpenWorkflowExecutionsRequest, opts ...grpc.CallOption) (*workflowservice.ListOpenWorkflowExecutionsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "ListOpenWorkflowExecutions", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.ListOpenWorkflowExecutionsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListOpenWorkflowExecutions indicates an expected call of ListOpenWorkflowExecutions.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) ListOpenWorkflowExecutions(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpenWorkflowExecutions", reflect.TypeOf((*MockWorkflowServiceClient)(nil).ListOpenWorkflowExecutions), varargs...)
|
|
}
|
|
|
|
// ListTaskQueuePartitions mocks base method.
|
|
func (m *MockWorkflowServiceClient) ListTaskQueuePartitions(ctx context.Context, in *workflowservice.ListTaskQueuePartitionsRequest, opts ...grpc.CallOption) (*workflowservice.ListTaskQueuePartitionsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "ListTaskQueuePartitions", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.ListTaskQueuePartitionsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListTaskQueuePartitions indicates an expected call of ListTaskQueuePartitions.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) ListTaskQueuePartitions(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskQueuePartitions", reflect.TypeOf((*MockWorkflowServiceClient)(nil).ListTaskQueuePartitions), varargs...)
|
|
}
|
|
|
|
// ListWorkflowExecutions mocks base method.
|
|
func (m *MockWorkflowServiceClient) ListWorkflowExecutions(ctx context.Context, in *workflowservice.ListWorkflowExecutionsRequest, opts ...grpc.CallOption) (*workflowservice.ListWorkflowExecutionsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "ListWorkflowExecutions", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.ListWorkflowExecutionsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListWorkflowExecutions indicates an expected call of ListWorkflowExecutions.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) ListWorkflowExecutions(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkflowExecutions", reflect.TypeOf((*MockWorkflowServiceClient)(nil).ListWorkflowExecutions), varargs...)
|
|
}
|
|
|
|
// PollActivityTaskQueue mocks base method.
|
|
func (m *MockWorkflowServiceClient) PollActivityTaskQueue(ctx context.Context, in *workflowservice.PollActivityTaskQueueRequest, opts ...grpc.CallOption) (*workflowservice.PollActivityTaskQueueResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "PollActivityTaskQueue", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.PollActivityTaskQueueResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// PollActivityTaskQueue indicates an expected call of PollActivityTaskQueue.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) PollActivityTaskQueue(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PollActivityTaskQueue", reflect.TypeOf((*MockWorkflowServiceClient)(nil).PollActivityTaskQueue), varargs...)
|
|
}
|
|
|
|
// PollWorkflowTaskQueue mocks base method.
|
|
func (m *MockWorkflowServiceClient) PollWorkflowTaskQueue(ctx context.Context, in *workflowservice.PollWorkflowTaskQueueRequest, opts ...grpc.CallOption) (*workflowservice.PollWorkflowTaskQueueResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "PollWorkflowTaskQueue", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.PollWorkflowTaskQueueResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// PollWorkflowTaskQueue indicates an expected call of PollWorkflowTaskQueue.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) PollWorkflowTaskQueue(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PollWorkflowTaskQueue", reflect.TypeOf((*MockWorkflowServiceClient)(nil).PollWorkflowTaskQueue), varargs...)
|
|
}
|
|
|
|
// QueryWorkflow mocks base method.
|
|
func (m *MockWorkflowServiceClient) QueryWorkflow(ctx context.Context, in *workflowservice.QueryWorkflowRequest, opts ...grpc.CallOption) (*workflowservice.QueryWorkflowResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "QueryWorkflow", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.QueryWorkflowResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// QueryWorkflow indicates an expected call of QueryWorkflow.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) QueryWorkflow(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryWorkflow", reflect.TypeOf((*MockWorkflowServiceClient)(nil).QueryWorkflow), varargs...)
|
|
}
|
|
|
|
// RecordActivityTaskHeartbeat mocks base method.
|
|
func (m *MockWorkflowServiceClient) RecordActivityTaskHeartbeat(ctx context.Context, in *workflowservice.RecordActivityTaskHeartbeatRequest, opts ...grpc.CallOption) (*workflowservice.RecordActivityTaskHeartbeatResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RecordActivityTaskHeartbeat", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.RecordActivityTaskHeartbeatResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RecordActivityTaskHeartbeat indicates an expected call of RecordActivityTaskHeartbeat.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) RecordActivityTaskHeartbeat(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordActivityTaskHeartbeat", reflect.TypeOf((*MockWorkflowServiceClient)(nil).RecordActivityTaskHeartbeat), varargs...)
|
|
}
|
|
|
|
// RecordActivityTaskHeartbeatById mocks base method.
|
|
func (m *MockWorkflowServiceClient) RecordActivityTaskHeartbeatById(ctx context.Context, in *workflowservice.RecordActivityTaskHeartbeatByIdRequest, opts ...grpc.CallOption) (*workflowservice.RecordActivityTaskHeartbeatByIdResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RecordActivityTaskHeartbeatById", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.RecordActivityTaskHeartbeatByIdResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RecordActivityTaskHeartbeatById indicates an expected call of RecordActivityTaskHeartbeatById.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) RecordActivityTaskHeartbeatById(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordActivityTaskHeartbeatById", reflect.TypeOf((*MockWorkflowServiceClient)(nil).RecordActivityTaskHeartbeatById), varargs...)
|
|
}
|
|
|
|
// RegisterNamespace mocks base method.
|
|
func (m *MockWorkflowServiceClient) RegisterNamespace(ctx context.Context, in *workflowservice.RegisterNamespaceRequest, opts ...grpc.CallOption) (*workflowservice.RegisterNamespaceResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RegisterNamespace", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.RegisterNamespaceResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RegisterNamespace indicates an expected call of RegisterNamespace.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) RegisterNamespace(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterNamespace", reflect.TypeOf((*MockWorkflowServiceClient)(nil).RegisterNamespace), varargs...)
|
|
}
|
|
|
|
// RequestCancelWorkflowExecution mocks base method.
|
|
func (m *MockWorkflowServiceClient) RequestCancelWorkflowExecution(ctx context.Context, in *workflowservice.RequestCancelWorkflowExecutionRequest, opts ...grpc.CallOption) (*workflowservice.RequestCancelWorkflowExecutionResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RequestCancelWorkflowExecution", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.RequestCancelWorkflowExecutionResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RequestCancelWorkflowExecution indicates an expected call of RequestCancelWorkflowExecution.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) RequestCancelWorkflowExecution(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestCancelWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).RequestCancelWorkflowExecution), varargs...)
|
|
}
|
|
|
|
// ResetStickyTaskQueue mocks base method.
|
|
func (m *MockWorkflowServiceClient) ResetStickyTaskQueue(ctx context.Context, in *workflowservice.ResetStickyTaskQueueRequest, opts ...grpc.CallOption) (*workflowservice.ResetStickyTaskQueueResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "ResetStickyTaskQueue", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.ResetStickyTaskQueueResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ResetStickyTaskQueue indicates an expected call of ResetStickyTaskQueue.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) ResetStickyTaskQueue(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetStickyTaskQueue", reflect.TypeOf((*MockWorkflowServiceClient)(nil).ResetStickyTaskQueue), varargs...)
|
|
}
|
|
|
|
// ResetWorkflowExecution mocks base method.
|
|
func (m *MockWorkflowServiceClient) ResetWorkflowExecution(ctx context.Context, in *workflowservice.ResetWorkflowExecutionRequest, opts ...grpc.CallOption) (*workflowservice.ResetWorkflowExecutionResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "ResetWorkflowExecution", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.ResetWorkflowExecutionResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ResetWorkflowExecution indicates an expected call of ResetWorkflowExecution.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) ResetWorkflowExecution(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).ResetWorkflowExecution), varargs...)
|
|
}
|
|
|
|
// RespondActivityTaskCanceled mocks base method.
|
|
func (m *MockWorkflowServiceClient) RespondActivityTaskCanceled(ctx context.Context, in *workflowservice.RespondActivityTaskCanceledRequest, opts ...grpc.CallOption) (*workflowservice.RespondActivityTaskCanceledResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RespondActivityTaskCanceled", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.RespondActivityTaskCanceledResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondActivityTaskCanceled indicates an expected call of RespondActivityTaskCanceled.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) RespondActivityTaskCanceled(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskCanceled", reflect.TypeOf((*MockWorkflowServiceClient)(nil).RespondActivityTaskCanceled), varargs...)
|
|
}
|
|
|
|
// RespondActivityTaskCanceledById mocks base method.
|
|
func (m *MockWorkflowServiceClient) RespondActivityTaskCanceledById(ctx context.Context, in *workflowservice.RespondActivityTaskCanceledByIdRequest, opts ...grpc.CallOption) (*workflowservice.RespondActivityTaskCanceledByIdResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RespondActivityTaskCanceledById", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.RespondActivityTaskCanceledByIdResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondActivityTaskCanceledById indicates an expected call of RespondActivityTaskCanceledById.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) RespondActivityTaskCanceledById(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskCanceledById", reflect.TypeOf((*MockWorkflowServiceClient)(nil).RespondActivityTaskCanceledById), varargs...)
|
|
}
|
|
|
|
// RespondActivityTaskCompleted mocks base method.
|
|
func (m *MockWorkflowServiceClient) RespondActivityTaskCompleted(ctx context.Context, in *workflowservice.RespondActivityTaskCompletedRequest, opts ...grpc.CallOption) (*workflowservice.RespondActivityTaskCompletedResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RespondActivityTaskCompleted", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.RespondActivityTaskCompletedResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondActivityTaskCompleted indicates an expected call of RespondActivityTaskCompleted.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) RespondActivityTaskCompleted(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskCompleted", reflect.TypeOf((*MockWorkflowServiceClient)(nil).RespondActivityTaskCompleted), varargs...)
|
|
}
|
|
|
|
// RespondActivityTaskCompletedById mocks base method.
|
|
func (m *MockWorkflowServiceClient) RespondActivityTaskCompletedById(ctx context.Context, in *workflowservice.RespondActivityTaskCompletedByIdRequest, opts ...grpc.CallOption) (*workflowservice.RespondActivityTaskCompletedByIdResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RespondActivityTaskCompletedById", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.RespondActivityTaskCompletedByIdResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondActivityTaskCompletedById indicates an expected call of RespondActivityTaskCompletedById.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) RespondActivityTaskCompletedById(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskCompletedById", reflect.TypeOf((*MockWorkflowServiceClient)(nil).RespondActivityTaskCompletedById), varargs...)
|
|
}
|
|
|
|
// RespondActivityTaskFailed mocks base method.
|
|
func (m *MockWorkflowServiceClient) RespondActivityTaskFailed(ctx context.Context, in *workflowservice.RespondActivityTaskFailedRequest, opts ...grpc.CallOption) (*workflowservice.RespondActivityTaskFailedResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RespondActivityTaskFailed", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.RespondActivityTaskFailedResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondActivityTaskFailed indicates an expected call of RespondActivityTaskFailed.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) RespondActivityTaskFailed(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskFailed", reflect.TypeOf((*MockWorkflowServiceClient)(nil).RespondActivityTaskFailed), varargs...)
|
|
}
|
|
|
|
// RespondActivityTaskFailedById mocks base method.
|
|
func (m *MockWorkflowServiceClient) RespondActivityTaskFailedById(ctx context.Context, in *workflowservice.RespondActivityTaskFailedByIdRequest, opts ...grpc.CallOption) (*workflowservice.RespondActivityTaskFailedByIdResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RespondActivityTaskFailedById", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.RespondActivityTaskFailedByIdResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondActivityTaskFailedById indicates an expected call of RespondActivityTaskFailedById.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) RespondActivityTaskFailedById(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskFailedById", reflect.TypeOf((*MockWorkflowServiceClient)(nil).RespondActivityTaskFailedById), varargs...)
|
|
}
|
|
|
|
// RespondQueryTaskCompleted mocks base method.
|
|
func (m *MockWorkflowServiceClient) RespondQueryTaskCompleted(ctx context.Context, in *workflowservice.RespondQueryTaskCompletedRequest, opts ...grpc.CallOption) (*workflowservice.RespondQueryTaskCompletedResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RespondQueryTaskCompleted", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.RespondQueryTaskCompletedResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondQueryTaskCompleted indicates an expected call of RespondQueryTaskCompleted.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) RespondQueryTaskCompleted(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondQueryTaskCompleted", reflect.TypeOf((*MockWorkflowServiceClient)(nil).RespondQueryTaskCompleted), varargs...)
|
|
}
|
|
|
|
// RespondWorkflowTaskCompleted mocks base method.
|
|
func (m *MockWorkflowServiceClient) RespondWorkflowTaskCompleted(ctx context.Context, in *workflowservice.RespondWorkflowTaskCompletedRequest, opts ...grpc.CallOption) (*workflowservice.RespondWorkflowTaskCompletedResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RespondWorkflowTaskCompleted", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.RespondWorkflowTaskCompletedResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondWorkflowTaskCompleted indicates an expected call of RespondWorkflowTaskCompleted.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) RespondWorkflowTaskCompleted(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondWorkflowTaskCompleted", reflect.TypeOf((*MockWorkflowServiceClient)(nil).RespondWorkflowTaskCompleted), varargs...)
|
|
}
|
|
|
|
// RespondWorkflowTaskFailed mocks base method.
|
|
func (m *MockWorkflowServiceClient) RespondWorkflowTaskFailed(ctx context.Context, in *workflowservice.RespondWorkflowTaskFailedRequest, opts ...grpc.CallOption) (*workflowservice.RespondWorkflowTaskFailedResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RespondWorkflowTaskFailed", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.RespondWorkflowTaskFailedResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondWorkflowTaskFailed indicates an expected call of RespondWorkflowTaskFailed.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) RespondWorkflowTaskFailed(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondWorkflowTaskFailed", reflect.TypeOf((*MockWorkflowServiceClient)(nil).RespondWorkflowTaskFailed), varargs...)
|
|
}
|
|
|
|
// ScanWorkflowExecutions mocks base method.
|
|
func (m *MockWorkflowServiceClient) ScanWorkflowExecutions(ctx context.Context, in *workflowservice.ScanWorkflowExecutionsRequest, opts ...grpc.CallOption) (*workflowservice.ScanWorkflowExecutionsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "ScanWorkflowExecutions", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.ScanWorkflowExecutionsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ScanWorkflowExecutions indicates an expected call of ScanWorkflowExecutions.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) ScanWorkflowExecutions(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanWorkflowExecutions", reflect.TypeOf((*MockWorkflowServiceClient)(nil).ScanWorkflowExecutions), varargs...)
|
|
}
|
|
|
|
// SignalWithStartWorkflowExecution mocks base method.
|
|
func (m *MockWorkflowServiceClient) SignalWithStartWorkflowExecution(ctx context.Context, in *workflowservice.SignalWithStartWorkflowExecutionRequest, opts ...grpc.CallOption) (*workflowservice.SignalWithStartWorkflowExecutionResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SignalWithStartWorkflowExecution", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.SignalWithStartWorkflowExecutionResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SignalWithStartWorkflowExecution indicates an expected call of SignalWithStartWorkflowExecution.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) SignalWithStartWorkflowExecution(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignalWithStartWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).SignalWithStartWorkflowExecution), varargs...)
|
|
}
|
|
|
|
// SignalWorkflowExecution mocks base method.
|
|
func (m *MockWorkflowServiceClient) SignalWorkflowExecution(ctx context.Context, in *workflowservice.SignalWorkflowExecutionRequest, opts ...grpc.CallOption) (*workflowservice.SignalWorkflowExecutionResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SignalWorkflowExecution", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.SignalWorkflowExecutionResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SignalWorkflowExecution indicates an expected call of SignalWorkflowExecution.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) SignalWorkflowExecution(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignalWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).SignalWorkflowExecution), varargs...)
|
|
}
|
|
|
|
// StartWorkflowExecution mocks base method.
|
|
func (m *MockWorkflowServiceClient) StartWorkflowExecution(ctx context.Context, in *workflowservice.StartWorkflowExecutionRequest, opts ...grpc.CallOption) (*workflowservice.StartWorkflowExecutionResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "StartWorkflowExecution", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.StartWorkflowExecutionResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// StartWorkflowExecution indicates an expected call of StartWorkflowExecution.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) StartWorkflowExecution(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).StartWorkflowExecution), varargs...)
|
|
}
|
|
|
|
// TerminateWorkflowExecution mocks base method.
|
|
func (m *MockWorkflowServiceClient) TerminateWorkflowExecution(ctx context.Context, in *workflowservice.TerminateWorkflowExecutionRequest, opts ...grpc.CallOption) (*workflowservice.TerminateWorkflowExecutionResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "TerminateWorkflowExecution", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.TerminateWorkflowExecutionResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// TerminateWorkflowExecution indicates an expected call of TerminateWorkflowExecution.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) TerminateWorkflowExecution(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).TerminateWorkflowExecution), varargs...)
|
|
}
|
|
|
|
// UpdateNamespace mocks base method.
|
|
func (m *MockWorkflowServiceClient) UpdateNamespace(ctx context.Context, in *workflowservice.UpdateNamespaceRequest, opts ...grpc.CallOption) (*workflowservice.UpdateNamespaceResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, in}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "UpdateNamespace", varargs...)
|
|
ret0, _ := ret[0].(*workflowservice.UpdateNamespaceResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpdateNamespace indicates an expected call of UpdateNamespace.
|
|
func (mr *MockWorkflowServiceClientMockRecorder) UpdateNamespace(ctx, in interface{}, opts ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, in}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNamespace", reflect.TypeOf((*MockWorkflowServiceClient)(nil).UpdateNamespace), varargs...)
|
|
}
|
|
|
|
// MockWorkflowServiceServer is a mock of WorkflowServiceServer interface.
|
|
type MockWorkflowServiceServer struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockWorkflowServiceServerMockRecorder
|
|
}
|
|
|
|
// MockWorkflowServiceServerMockRecorder is the mock recorder for MockWorkflowServiceServer.
|
|
type MockWorkflowServiceServerMockRecorder struct {
|
|
mock *MockWorkflowServiceServer
|
|
}
|
|
|
|
// NewMockWorkflowServiceServer creates a new mock instance.
|
|
func NewMockWorkflowServiceServer(ctrl *gomock.Controller) *MockWorkflowServiceServer {
|
|
mock := &MockWorkflowServiceServer{ctrl: ctrl}
|
|
mock.recorder = &MockWorkflowServiceServerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockWorkflowServiceServer) EXPECT() *MockWorkflowServiceServerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// CountWorkflowExecutions mocks base method.
|
|
func (m *MockWorkflowServiceServer) CountWorkflowExecutions(arg0 context.Context, arg1 *workflowservice.CountWorkflowExecutionsRequest) (*workflowservice.CountWorkflowExecutionsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CountWorkflowExecutions", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.CountWorkflowExecutionsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CountWorkflowExecutions indicates an expected call of CountWorkflowExecutions.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) CountWorkflowExecutions(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountWorkflowExecutions", reflect.TypeOf((*MockWorkflowServiceServer)(nil).CountWorkflowExecutions), arg0, arg1)
|
|
}
|
|
|
|
// DeprecateNamespace mocks base method.
|
|
func (m *MockWorkflowServiceServer) DeprecateNamespace(arg0 context.Context, arg1 *workflowservice.DeprecateNamespaceRequest) (*workflowservice.DeprecateNamespaceResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeprecateNamespace", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.DeprecateNamespaceResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DeprecateNamespace indicates an expected call of DeprecateNamespace.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) DeprecateNamespace(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprecateNamespace", reflect.TypeOf((*MockWorkflowServiceServer)(nil).DeprecateNamespace), arg0, arg1)
|
|
}
|
|
|
|
// DescribeNamespace mocks base method.
|
|
func (m *MockWorkflowServiceServer) DescribeNamespace(arg0 context.Context, arg1 *workflowservice.DescribeNamespaceRequest) (*workflowservice.DescribeNamespaceResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DescribeNamespace", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.DescribeNamespaceResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DescribeNamespace indicates an expected call of DescribeNamespace.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) DescribeNamespace(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNamespace", reflect.TypeOf((*MockWorkflowServiceServer)(nil).DescribeNamespace), arg0, arg1)
|
|
}
|
|
|
|
// DescribeTaskQueue mocks base method.
|
|
func (m *MockWorkflowServiceServer) DescribeTaskQueue(arg0 context.Context, arg1 *workflowservice.DescribeTaskQueueRequest) (*workflowservice.DescribeTaskQueueResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DescribeTaskQueue", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.DescribeTaskQueueResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DescribeTaskQueue indicates an expected call of DescribeTaskQueue.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) DescribeTaskQueue(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTaskQueue", reflect.TypeOf((*MockWorkflowServiceServer)(nil).DescribeTaskQueue), arg0, arg1)
|
|
}
|
|
|
|
// DescribeWorkflowExecution mocks base method.
|
|
func (m *MockWorkflowServiceServer) DescribeWorkflowExecution(arg0 context.Context, arg1 *workflowservice.DescribeWorkflowExecutionRequest) (*workflowservice.DescribeWorkflowExecutionResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DescribeWorkflowExecution", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.DescribeWorkflowExecutionResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DescribeWorkflowExecution indicates an expected call of DescribeWorkflowExecution.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) DescribeWorkflowExecution(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceServer)(nil).DescribeWorkflowExecution), arg0, arg1)
|
|
}
|
|
|
|
// GetClusterInfo mocks base method.
|
|
func (m *MockWorkflowServiceServer) GetClusterInfo(arg0 context.Context, arg1 *workflowservice.GetClusterInfoRequest) (*workflowservice.GetClusterInfoResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetClusterInfo", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.GetClusterInfoResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetClusterInfo indicates an expected call of GetClusterInfo.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) GetClusterInfo(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterInfo", reflect.TypeOf((*MockWorkflowServiceServer)(nil).GetClusterInfo), arg0, arg1)
|
|
}
|
|
|
|
// GetSearchAttributes mocks base method.
|
|
func (m *MockWorkflowServiceServer) GetSearchAttributes(arg0 context.Context, arg1 *workflowservice.GetSearchAttributesRequest) (*workflowservice.GetSearchAttributesResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetSearchAttributes", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.GetSearchAttributesResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetSearchAttributes indicates an expected call of GetSearchAttributes.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) GetSearchAttributes(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSearchAttributes", reflect.TypeOf((*MockWorkflowServiceServer)(nil).GetSearchAttributes), arg0, arg1)
|
|
}
|
|
|
|
// GetWorkflowExecutionHistory mocks base method.
|
|
func (m *MockWorkflowServiceServer) GetWorkflowExecutionHistory(arg0 context.Context, arg1 *workflowservice.GetWorkflowExecutionHistoryRequest) (*workflowservice.GetWorkflowExecutionHistoryResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkflowExecutionHistory", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.GetWorkflowExecutionHistoryResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetWorkflowExecutionHistory indicates an expected call of GetWorkflowExecutionHistory.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) GetWorkflowExecutionHistory(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowExecutionHistory", reflect.TypeOf((*MockWorkflowServiceServer)(nil).GetWorkflowExecutionHistory), arg0, arg1)
|
|
}
|
|
|
|
// ListArchivedWorkflowExecutions mocks base method.
|
|
func (m *MockWorkflowServiceServer) ListArchivedWorkflowExecutions(arg0 context.Context, arg1 *workflowservice.ListArchivedWorkflowExecutionsRequest) (*workflowservice.ListArchivedWorkflowExecutionsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ListArchivedWorkflowExecutions", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.ListArchivedWorkflowExecutionsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListArchivedWorkflowExecutions indicates an expected call of ListArchivedWorkflowExecutions.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) ListArchivedWorkflowExecutions(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListArchivedWorkflowExecutions", reflect.TypeOf((*MockWorkflowServiceServer)(nil).ListArchivedWorkflowExecutions), arg0, arg1)
|
|
}
|
|
|
|
// ListClosedWorkflowExecutions mocks base method.
|
|
func (m *MockWorkflowServiceServer) ListClosedWorkflowExecutions(arg0 context.Context, arg1 *workflowservice.ListClosedWorkflowExecutionsRequest) (*workflowservice.ListClosedWorkflowExecutionsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ListClosedWorkflowExecutions", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.ListClosedWorkflowExecutionsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListClosedWorkflowExecutions indicates an expected call of ListClosedWorkflowExecutions.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) ListClosedWorkflowExecutions(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClosedWorkflowExecutions", reflect.TypeOf((*MockWorkflowServiceServer)(nil).ListClosedWorkflowExecutions), arg0, arg1)
|
|
}
|
|
|
|
// ListNamespaces mocks base method.
|
|
func (m *MockWorkflowServiceServer) ListNamespaces(arg0 context.Context, arg1 *workflowservice.ListNamespacesRequest) (*workflowservice.ListNamespacesResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ListNamespaces", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.ListNamespacesResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListNamespaces indicates an expected call of ListNamespaces.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) ListNamespaces(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNamespaces", reflect.TypeOf((*MockWorkflowServiceServer)(nil).ListNamespaces), arg0, arg1)
|
|
}
|
|
|
|
// ListOpenWorkflowExecutions mocks base method.
|
|
func (m *MockWorkflowServiceServer) ListOpenWorkflowExecutions(arg0 context.Context, arg1 *workflowservice.ListOpenWorkflowExecutionsRequest) (*workflowservice.ListOpenWorkflowExecutionsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ListOpenWorkflowExecutions", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.ListOpenWorkflowExecutionsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListOpenWorkflowExecutions indicates an expected call of ListOpenWorkflowExecutions.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) ListOpenWorkflowExecutions(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpenWorkflowExecutions", reflect.TypeOf((*MockWorkflowServiceServer)(nil).ListOpenWorkflowExecutions), arg0, arg1)
|
|
}
|
|
|
|
// ListTaskQueuePartitions mocks base method.
|
|
func (m *MockWorkflowServiceServer) ListTaskQueuePartitions(arg0 context.Context, arg1 *workflowservice.ListTaskQueuePartitionsRequest) (*workflowservice.ListTaskQueuePartitionsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ListTaskQueuePartitions", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.ListTaskQueuePartitionsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListTaskQueuePartitions indicates an expected call of ListTaskQueuePartitions.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) ListTaskQueuePartitions(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskQueuePartitions", reflect.TypeOf((*MockWorkflowServiceServer)(nil).ListTaskQueuePartitions), arg0, arg1)
|
|
}
|
|
|
|
// ListWorkflowExecutions mocks base method.
|
|
func (m *MockWorkflowServiceServer) ListWorkflowExecutions(arg0 context.Context, arg1 *workflowservice.ListWorkflowExecutionsRequest) (*workflowservice.ListWorkflowExecutionsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ListWorkflowExecutions", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.ListWorkflowExecutionsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListWorkflowExecutions indicates an expected call of ListWorkflowExecutions.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) ListWorkflowExecutions(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkflowExecutions", reflect.TypeOf((*MockWorkflowServiceServer)(nil).ListWorkflowExecutions), arg0, arg1)
|
|
}
|
|
|
|
// PollActivityTaskQueue mocks base method.
|
|
func (m *MockWorkflowServiceServer) PollActivityTaskQueue(arg0 context.Context, arg1 *workflowservice.PollActivityTaskQueueRequest) (*workflowservice.PollActivityTaskQueueResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "PollActivityTaskQueue", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.PollActivityTaskQueueResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// PollActivityTaskQueue indicates an expected call of PollActivityTaskQueue.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) PollActivityTaskQueue(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PollActivityTaskQueue", reflect.TypeOf((*MockWorkflowServiceServer)(nil).PollActivityTaskQueue), arg0, arg1)
|
|
}
|
|
|
|
// PollWorkflowTaskQueue mocks base method.
|
|
func (m *MockWorkflowServiceServer) PollWorkflowTaskQueue(arg0 context.Context, arg1 *workflowservice.PollWorkflowTaskQueueRequest) (*workflowservice.PollWorkflowTaskQueueResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "PollWorkflowTaskQueue", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.PollWorkflowTaskQueueResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// PollWorkflowTaskQueue indicates an expected call of PollWorkflowTaskQueue.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) PollWorkflowTaskQueue(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PollWorkflowTaskQueue", reflect.TypeOf((*MockWorkflowServiceServer)(nil).PollWorkflowTaskQueue), arg0, arg1)
|
|
}
|
|
|
|
// QueryWorkflow mocks base method.
|
|
func (m *MockWorkflowServiceServer) QueryWorkflow(arg0 context.Context, arg1 *workflowservice.QueryWorkflowRequest) (*workflowservice.QueryWorkflowResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "QueryWorkflow", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.QueryWorkflowResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// QueryWorkflow indicates an expected call of QueryWorkflow.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) QueryWorkflow(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryWorkflow", reflect.TypeOf((*MockWorkflowServiceServer)(nil).QueryWorkflow), arg0, arg1)
|
|
}
|
|
|
|
// RecordActivityTaskHeartbeat mocks base method.
|
|
func (m *MockWorkflowServiceServer) RecordActivityTaskHeartbeat(arg0 context.Context, arg1 *workflowservice.RecordActivityTaskHeartbeatRequest) (*workflowservice.RecordActivityTaskHeartbeatResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RecordActivityTaskHeartbeat", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.RecordActivityTaskHeartbeatResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RecordActivityTaskHeartbeat indicates an expected call of RecordActivityTaskHeartbeat.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) RecordActivityTaskHeartbeat(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordActivityTaskHeartbeat", reflect.TypeOf((*MockWorkflowServiceServer)(nil).RecordActivityTaskHeartbeat), arg0, arg1)
|
|
}
|
|
|
|
// RecordActivityTaskHeartbeatById mocks base method.
|
|
func (m *MockWorkflowServiceServer) RecordActivityTaskHeartbeatById(arg0 context.Context, arg1 *workflowservice.RecordActivityTaskHeartbeatByIdRequest) (*workflowservice.RecordActivityTaskHeartbeatByIdResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RecordActivityTaskHeartbeatById", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.RecordActivityTaskHeartbeatByIdResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RecordActivityTaskHeartbeatById indicates an expected call of RecordActivityTaskHeartbeatById.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) RecordActivityTaskHeartbeatById(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordActivityTaskHeartbeatById", reflect.TypeOf((*MockWorkflowServiceServer)(nil).RecordActivityTaskHeartbeatById), arg0, arg1)
|
|
}
|
|
|
|
// RegisterNamespace mocks base method.
|
|
func (m *MockWorkflowServiceServer) RegisterNamespace(arg0 context.Context, arg1 *workflowservice.RegisterNamespaceRequest) (*workflowservice.RegisterNamespaceResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RegisterNamespace", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.RegisterNamespaceResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RegisterNamespace indicates an expected call of RegisterNamespace.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) RegisterNamespace(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterNamespace", reflect.TypeOf((*MockWorkflowServiceServer)(nil).RegisterNamespace), arg0, arg1)
|
|
}
|
|
|
|
// RequestCancelWorkflowExecution mocks base method.
|
|
func (m *MockWorkflowServiceServer) RequestCancelWorkflowExecution(arg0 context.Context, arg1 *workflowservice.RequestCancelWorkflowExecutionRequest) (*workflowservice.RequestCancelWorkflowExecutionResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RequestCancelWorkflowExecution", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.RequestCancelWorkflowExecutionResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RequestCancelWorkflowExecution indicates an expected call of RequestCancelWorkflowExecution.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) RequestCancelWorkflowExecution(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestCancelWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceServer)(nil).RequestCancelWorkflowExecution), arg0, arg1)
|
|
}
|
|
|
|
// ResetStickyTaskQueue mocks base method.
|
|
func (m *MockWorkflowServiceServer) ResetStickyTaskQueue(arg0 context.Context, arg1 *workflowservice.ResetStickyTaskQueueRequest) (*workflowservice.ResetStickyTaskQueueResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ResetStickyTaskQueue", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.ResetStickyTaskQueueResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ResetStickyTaskQueue indicates an expected call of ResetStickyTaskQueue.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) ResetStickyTaskQueue(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetStickyTaskQueue", reflect.TypeOf((*MockWorkflowServiceServer)(nil).ResetStickyTaskQueue), arg0, arg1)
|
|
}
|
|
|
|
// ResetWorkflowExecution mocks base method.
|
|
func (m *MockWorkflowServiceServer) ResetWorkflowExecution(arg0 context.Context, arg1 *workflowservice.ResetWorkflowExecutionRequest) (*workflowservice.ResetWorkflowExecutionResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ResetWorkflowExecution", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.ResetWorkflowExecutionResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ResetWorkflowExecution indicates an expected call of ResetWorkflowExecution.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) ResetWorkflowExecution(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceServer)(nil).ResetWorkflowExecution), arg0, arg1)
|
|
}
|
|
|
|
// RespondActivityTaskCanceled mocks base method.
|
|
func (m *MockWorkflowServiceServer) RespondActivityTaskCanceled(arg0 context.Context, arg1 *workflowservice.RespondActivityTaskCanceledRequest) (*workflowservice.RespondActivityTaskCanceledResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RespondActivityTaskCanceled", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.RespondActivityTaskCanceledResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondActivityTaskCanceled indicates an expected call of RespondActivityTaskCanceled.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) RespondActivityTaskCanceled(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskCanceled", reflect.TypeOf((*MockWorkflowServiceServer)(nil).RespondActivityTaskCanceled), arg0, arg1)
|
|
}
|
|
|
|
// RespondActivityTaskCanceledById mocks base method.
|
|
func (m *MockWorkflowServiceServer) RespondActivityTaskCanceledById(arg0 context.Context, arg1 *workflowservice.RespondActivityTaskCanceledByIdRequest) (*workflowservice.RespondActivityTaskCanceledByIdResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RespondActivityTaskCanceledById", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.RespondActivityTaskCanceledByIdResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondActivityTaskCanceledById indicates an expected call of RespondActivityTaskCanceledById.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) RespondActivityTaskCanceledById(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskCanceledById", reflect.TypeOf((*MockWorkflowServiceServer)(nil).RespondActivityTaskCanceledById), arg0, arg1)
|
|
}
|
|
|
|
// RespondActivityTaskCompleted mocks base method.
|
|
func (m *MockWorkflowServiceServer) RespondActivityTaskCompleted(arg0 context.Context, arg1 *workflowservice.RespondActivityTaskCompletedRequest) (*workflowservice.RespondActivityTaskCompletedResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RespondActivityTaskCompleted", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.RespondActivityTaskCompletedResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondActivityTaskCompleted indicates an expected call of RespondActivityTaskCompleted.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) RespondActivityTaskCompleted(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskCompleted", reflect.TypeOf((*MockWorkflowServiceServer)(nil).RespondActivityTaskCompleted), arg0, arg1)
|
|
}
|
|
|
|
// RespondActivityTaskCompletedById mocks base method.
|
|
func (m *MockWorkflowServiceServer) RespondActivityTaskCompletedById(arg0 context.Context, arg1 *workflowservice.RespondActivityTaskCompletedByIdRequest) (*workflowservice.RespondActivityTaskCompletedByIdResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RespondActivityTaskCompletedById", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.RespondActivityTaskCompletedByIdResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondActivityTaskCompletedById indicates an expected call of RespondActivityTaskCompletedById.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) RespondActivityTaskCompletedById(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskCompletedById", reflect.TypeOf((*MockWorkflowServiceServer)(nil).RespondActivityTaskCompletedById), arg0, arg1)
|
|
}
|
|
|
|
// RespondActivityTaskFailed mocks base method.
|
|
func (m *MockWorkflowServiceServer) RespondActivityTaskFailed(arg0 context.Context, arg1 *workflowservice.RespondActivityTaskFailedRequest) (*workflowservice.RespondActivityTaskFailedResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RespondActivityTaskFailed", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.RespondActivityTaskFailedResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondActivityTaskFailed indicates an expected call of RespondActivityTaskFailed.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) RespondActivityTaskFailed(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskFailed", reflect.TypeOf((*MockWorkflowServiceServer)(nil).RespondActivityTaskFailed), arg0, arg1)
|
|
}
|
|
|
|
// RespondActivityTaskFailedById mocks base method.
|
|
func (m *MockWorkflowServiceServer) RespondActivityTaskFailedById(arg0 context.Context, arg1 *workflowservice.RespondActivityTaskFailedByIdRequest) (*workflowservice.RespondActivityTaskFailedByIdResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RespondActivityTaskFailedById", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.RespondActivityTaskFailedByIdResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondActivityTaskFailedById indicates an expected call of RespondActivityTaskFailedById.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) RespondActivityTaskFailedById(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskFailedById", reflect.TypeOf((*MockWorkflowServiceServer)(nil).RespondActivityTaskFailedById), arg0, arg1)
|
|
}
|
|
|
|
// RespondQueryTaskCompleted mocks base method.
|
|
func (m *MockWorkflowServiceServer) RespondQueryTaskCompleted(arg0 context.Context, arg1 *workflowservice.RespondQueryTaskCompletedRequest) (*workflowservice.RespondQueryTaskCompletedResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RespondQueryTaskCompleted", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.RespondQueryTaskCompletedResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondQueryTaskCompleted indicates an expected call of RespondQueryTaskCompleted.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) RespondQueryTaskCompleted(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondQueryTaskCompleted", reflect.TypeOf((*MockWorkflowServiceServer)(nil).RespondQueryTaskCompleted), arg0, arg1)
|
|
}
|
|
|
|
// RespondWorkflowTaskCompleted mocks base method.
|
|
func (m *MockWorkflowServiceServer) RespondWorkflowTaskCompleted(arg0 context.Context, arg1 *workflowservice.RespondWorkflowTaskCompletedRequest) (*workflowservice.RespondWorkflowTaskCompletedResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RespondWorkflowTaskCompleted", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.RespondWorkflowTaskCompletedResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondWorkflowTaskCompleted indicates an expected call of RespondWorkflowTaskCompleted.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) RespondWorkflowTaskCompleted(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondWorkflowTaskCompleted", reflect.TypeOf((*MockWorkflowServiceServer)(nil).RespondWorkflowTaskCompleted), arg0, arg1)
|
|
}
|
|
|
|
// RespondWorkflowTaskFailed mocks base method.
|
|
func (m *MockWorkflowServiceServer) RespondWorkflowTaskFailed(arg0 context.Context, arg1 *workflowservice.RespondWorkflowTaskFailedRequest) (*workflowservice.RespondWorkflowTaskFailedResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RespondWorkflowTaskFailed", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.RespondWorkflowTaskFailedResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RespondWorkflowTaskFailed indicates an expected call of RespondWorkflowTaskFailed.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) RespondWorkflowTaskFailed(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondWorkflowTaskFailed", reflect.TypeOf((*MockWorkflowServiceServer)(nil).RespondWorkflowTaskFailed), arg0, arg1)
|
|
}
|
|
|
|
// ScanWorkflowExecutions mocks base method.
|
|
func (m *MockWorkflowServiceServer) ScanWorkflowExecutions(arg0 context.Context, arg1 *workflowservice.ScanWorkflowExecutionsRequest) (*workflowservice.ScanWorkflowExecutionsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ScanWorkflowExecutions", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.ScanWorkflowExecutionsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ScanWorkflowExecutions indicates an expected call of ScanWorkflowExecutions.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) ScanWorkflowExecutions(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanWorkflowExecutions", reflect.TypeOf((*MockWorkflowServiceServer)(nil).ScanWorkflowExecutions), arg0, arg1)
|
|
}
|
|
|
|
// SignalWithStartWorkflowExecution mocks base method.
|
|
func (m *MockWorkflowServiceServer) SignalWithStartWorkflowExecution(arg0 context.Context, arg1 *workflowservice.SignalWithStartWorkflowExecutionRequest) (*workflowservice.SignalWithStartWorkflowExecutionResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SignalWithStartWorkflowExecution", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.SignalWithStartWorkflowExecutionResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SignalWithStartWorkflowExecution indicates an expected call of SignalWithStartWorkflowExecution.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) SignalWithStartWorkflowExecution(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignalWithStartWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceServer)(nil).SignalWithStartWorkflowExecution), arg0, arg1)
|
|
}
|
|
|
|
// SignalWorkflowExecution mocks base method.
|
|
func (m *MockWorkflowServiceServer) SignalWorkflowExecution(arg0 context.Context, arg1 *workflowservice.SignalWorkflowExecutionRequest) (*workflowservice.SignalWorkflowExecutionResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SignalWorkflowExecution", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.SignalWorkflowExecutionResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SignalWorkflowExecution indicates an expected call of SignalWorkflowExecution.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) SignalWorkflowExecution(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignalWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceServer)(nil).SignalWorkflowExecution), arg0, arg1)
|
|
}
|
|
|
|
// StartWorkflowExecution mocks base method.
|
|
func (m *MockWorkflowServiceServer) StartWorkflowExecution(arg0 context.Context, arg1 *workflowservice.StartWorkflowExecutionRequest) (*workflowservice.StartWorkflowExecutionResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StartWorkflowExecution", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.StartWorkflowExecutionResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// StartWorkflowExecution indicates an expected call of StartWorkflowExecution.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) StartWorkflowExecution(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceServer)(nil).StartWorkflowExecution), arg0, arg1)
|
|
}
|
|
|
|
// TerminateWorkflowExecution mocks base method.
|
|
func (m *MockWorkflowServiceServer) TerminateWorkflowExecution(arg0 context.Context, arg1 *workflowservice.TerminateWorkflowExecutionRequest) (*workflowservice.TerminateWorkflowExecutionResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TerminateWorkflowExecution", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.TerminateWorkflowExecutionResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// TerminateWorkflowExecution indicates an expected call of TerminateWorkflowExecution.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) TerminateWorkflowExecution(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceServer)(nil).TerminateWorkflowExecution), arg0, arg1)
|
|
}
|
|
|
|
// UpdateNamespace mocks base method.
|
|
func (m *MockWorkflowServiceServer) UpdateNamespace(arg0 context.Context, arg1 *workflowservice.UpdateNamespaceRequest) (*workflowservice.UpdateNamespaceResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateNamespace", arg0, arg1)
|
|
ret0, _ := ret[0].(*workflowservice.UpdateNamespaceResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpdateNamespace indicates an expected call of UpdateNamespace.
|
|
func (mr *MockWorkflowServiceServerMockRecorder) UpdateNamespace(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNamespace", reflect.TypeOf((*MockWorkflowServiceServer)(nil).UpdateNamespace), arg0, arg1)
|
|
}
|