From 7503b55007cad9a27c0033b346213e405fa87edc Mon Sep 17 00:00:00 2001 From: Vytautas Karpavicius Date: Tue, 1 Jun 2021 20:17:40 +0300 Subject: [PATCH] Add api.Interface and its mock --- internal/api/interface.go | 32 ++ internal/api/interface_mock.go | 817 +++++++++++++++++++++++++++++++++ 2 files changed, 849 insertions(+) create mode 100644 internal/api/interface.go create mode 100644 internal/api/interface_mock.go diff --git a/internal/api/interface.go b/internal/api/interface.go new file mode 100644 index 000000000..187c3bb67 --- /dev/null +++ b/internal/api/interface.go @@ -0,0 +1,32 @@ +// Copyright (c) 2017-2020 Uber Technologies Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +package api + +import apiv1 "go.uber.org/cadence/v1/.gen/proto/api/v1" + +//go:generate mockgen -package $GOPACKAGE -source $GOFILE -destination interface_mock.go -self_package go.uber.org/cadence/v1/internal/api + +type Interface interface { + apiv1.DomainAPIYARPCClient + apiv1.VisibilityAPIYARPCClient + apiv1.WorkflowAPIYARPCClient + apiv1.WorkerAPIYARPCClient +} \ No newline at end of file diff --git a/internal/api/interface_mock.go b/internal/api/interface_mock.go new file mode 100644 index 000000000..fd9df6e01 --- /dev/null +++ b/internal/api/interface_mock.go @@ -0,0 +1,817 @@ +// Copyright (c) 2017-2020 Uber Technologies Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +// Code generated by MockGen. DO NOT EDIT. +// Source: interface.go + +// Package api is a generated GoMock package. +package api + +import ( + context "context" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + apiv1 "go.uber.org/cadence/v1/.gen/proto/api/v1" + yarpc "go.uber.org/yarpc" +) + +// MockInterface is a mock of Interface interface. +type MockInterface struct { + ctrl *gomock.Controller + recorder *MockInterfaceMockRecorder +} + +// MockInterfaceMockRecorder is the mock recorder for MockInterface. +type MockInterfaceMockRecorder struct { + mock *MockInterface +} + +// NewMockInterface creates a new mock instance. +func NewMockInterface(ctrl *gomock.Controller) *MockInterface { + mock := &MockInterface{ctrl: ctrl} + mock.recorder = &MockInterfaceMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder { + return m.recorder +} + +// CountWorkflowExecutions mocks base method. +func (m *MockInterface) CountWorkflowExecutions(arg0 context.Context, arg1 *apiv1.CountWorkflowExecutionsRequest, arg2 ...yarpc.CallOption) (*apiv1.CountWorkflowExecutionsResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CountWorkflowExecutions", varargs...) + ret0, _ := ret[0].(*apiv1.CountWorkflowExecutionsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CountWorkflowExecutions indicates an expected call of CountWorkflowExecutions. +func (mr *MockInterfaceMockRecorder) CountWorkflowExecutions(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountWorkflowExecutions", reflect.TypeOf((*MockInterface)(nil).CountWorkflowExecutions), varargs...) +} + +// DeprecateDomain mocks base method. +func (m *MockInterface) DeprecateDomain(arg0 context.Context, arg1 *apiv1.DeprecateDomainRequest, arg2 ...yarpc.CallOption) (*apiv1.DeprecateDomainResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeprecateDomain", varargs...) + ret0, _ := ret[0].(*apiv1.DeprecateDomainResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeprecateDomain indicates an expected call of DeprecateDomain. +func (mr *MockInterfaceMockRecorder) DeprecateDomain(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprecateDomain", reflect.TypeOf((*MockInterface)(nil).DeprecateDomain), varargs...) +} + +// DescribeDomain mocks base method. +func (m *MockInterface) DescribeDomain(arg0 context.Context, arg1 *apiv1.DescribeDomainRequest, arg2 ...yarpc.CallOption) (*apiv1.DescribeDomainResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeDomain", varargs...) + ret0, _ := ret[0].(*apiv1.DescribeDomainResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeDomain indicates an expected call of DescribeDomain. +func (mr *MockInterfaceMockRecorder) DescribeDomain(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDomain", reflect.TypeOf((*MockInterface)(nil).DescribeDomain), varargs...) +} + +// DescribeTaskList mocks base method. +func (m *MockInterface) DescribeTaskList(arg0 context.Context, arg1 *apiv1.DescribeTaskListRequest, arg2 ...yarpc.CallOption) (*apiv1.DescribeTaskListResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTaskList", varargs...) + ret0, _ := ret[0].(*apiv1.DescribeTaskListResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTaskList indicates an expected call of DescribeTaskList. +func (mr *MockInterfaceMockRecorder) DescribeTaskList(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTaskList", reflect.TypeOf((*MockInterface)(nil).DescribeTaskList), varargs...) +} + +// DescribeWorkflowExecution mocks base method. +func (m *MockInterface) DescribeWorkflowExecution(arg0 context.Context, arg1 *apiv1.DescribeWorkflowExecutionRequest, arg2 ...yarpc.CallOption) (*apiv1.DescribeWorkflowExecutionResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeWorkflowExecution", varargs...) + ret0, _ := ret[0].(*apiv1.DescribeWorkflowExecutionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeWorkflowExecution indicates an expected call of DescribeWorkflowExecution. +func (mr *MockInterfaceMockRecorder) DescribeWorkflowExecution(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeWorkflowExecution", reflect.TypeOf((*MockInterface)(nil).DescribeWorkflowExecution), varargs...) +} + +// GetClusterInfo mocks base method. +func (m *MockInterface) GetClusterInfo(arg0 context.Context, arg1 *apiv1.GetClusterInfoRequest, arg2 ...yarpc.CallOption) (*apiv1.GetClusterInfoResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetClusterInfo", varargs...) + ret0, _ := ret[0].(*apiv1.GetClusterInfoResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetClusterInfo indicates an expected call of GetClusterInfo. +func (mr *MockInterfaceMockRecorder) GetClusterInfo(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterInfo", reflect.TypeOf((*MockInterface)(nil).GetClusterInfo), varargs...) +} + +// GetSearchAttributes mocks base method. +func (m *MockInterface) GetSearchAttributes(arg0 context.Context, arg1 *apiv1.GetSearchAttributesRequest, arg2 ...yarpc.CallOption) (*apiv1.GetSearchAttributesResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetSearchAttributes", varargs...) + ret0, _ := ret[0].(*apiv1.GetSearchAttributesResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSearchAttributes indicates an expected call of GetSearchAttributes. +func (mr *MockInterfaceMockRecorder) GetSearchAttributes(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSearchAttributes", reflect.TypeOf((*MockInterface)(nil).GetSearchAttributes), varargs...) +} + +// GetWorkflowExecutionHistory mocks base method. +func (m *MockInterface) GetWorkflowExecutionHistory(arg0 context.Context, arg1 *apiv1.GetWorkflowExecutionHistoryRequest, arg2 ...yarpc.CallOption) (*apiv1.GetWorkflowExecutionHistoryResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetWorkflowExecutionHistory", varargs...) + ret0, _ := ret[0].(*apiv1.GetWorkflowExecutionHistoryResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetWorkflowExecutionHistory indicates an expected call of GetWorkflowExecutionHistory. +func (mr *MockInterfaceMockRecorder) GetWorkflowExecutionHistory(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowExecutionHistory", reflect.TypeOf((*MockInterface)(nil).GetWorkflowExecutionHistory), varargs...) +} + +// ListArchivedWorkflowExecutions mocks base method. +func (m *MockInterface) ListArchivedWorkflowExecutions(arg0 context.Context, arg1 *apiv1.ListArchivedWorkflowExecutionsRequest, arg2 ...yarpc.CallOption) (*apiv1.ListArchivedWorkflowExecutionsResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListArchivedWorkflowExecutions", varargs...) + ret0, _ := ret[0].(*apiv1.ListArchivedWorkflowExecutionsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListArchivedWorkflowExecutions indicates an expected call of ListArchivedWorkflowExecutions. +func (mr *MockInterfaceMockRecorder) ListArchivedWorkflowExecutions(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListArchivedWorkflowExecutions", reflect.TypeOf((*MockInterface)(nil).ListArchivedWorkflowExecutions), varargs...) +} + +// ListClosedWorkflowExecutions mocks base method. +func (m *MockInterface) ListClosedWorkflowExecutions(arg0 context.Context, arg1 *apiv1.ListClosedWorkflowExecutionsRequest, arg2 ...yarpc.CallOption) (*apiv1.ListClosedWorkflowExecutionsResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListClosedWorkflowExecutions", varargs...) + ret0, _ := ret[0].(*apiv1.ListClosedWorkflowExecutionsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListClosedWorkflowExecutions indicates an expected call of ListClosedWorkflowExecutions. +func (mr *MockInterfaceMockRecorder) ListClosedWorkflowExecutions(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClosedWorkflowExecutions", reflect.TypeOf((*MockInterface)(nil).ListClosedWorkflowExecutions), varargs...) +} + +// ListDomains mocks base method. +func (m *MockInterface) ListDomains(arg0 context.Context, arg1 *apiv1.ListDomainsRequest, arg2 ...yarpc.CallOption) (*apiv1.ListDomainsResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListDomains", varargs...) + ret0, _ := ret[0].(*apiv1.ListDomainsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListDomains indicates an expected call of ListDomains. +func (mr *MockInterfaceMockRecorder) ListDomains(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDomains", reflect.TypeOf((*MockInterface)(nil).ListDomains), varargs...) +} + +// ListOpenWorkflowExecutions mocks base method. +func (m *MockInterface) ListOpenWorkflowExecutions(arg0 context.Context, arg1 *apiv1.ListOpenWorkflowExecutionsRequest, arg2 ...yarpc.CallOption) (*apiv1.ListOpenWorkflowExecutionsResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListOpenWorkflowExecutions", varargs...) + ret0, _ := ret[0].(*apiv1.ListOpenWorkflowExecutionsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListOpenWorkflowExecutions indicates an expected call of ListOpenWorkflowExecutions. +func (mr *MockInterfaceMockRecorder) ListOpenWorkflowExecutions(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpenWorkflowExecutions", reflect.TypeOf((*MockInterface)(nil).ListOpenWorkflowExecutions), varargs...) +} + +// ListTaskListPartitions mocks base method. +func (m *MockInterface) ListTaskListPartitions(arg0 context.Context, arg1 *apiv1.ListTaskListPartitionsRequest, arg2 ...yarpc.CallOption) (*apiv1.ListTaskListPartitionsResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTaskListPartitions", varargs...) + ret0, _ := ret[0].(*apiv1.ListTaskListPartitionsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTaskListPartitions indicates an expected call of ListTaskListPartitions. +func (mr *MockInterfaceMockRecorder) ListTaskListPartitions(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskListPartitions", reflect.TypeOf((*MockInterface)(nil).ListTaskListPartitions), varargs...) +} + +// ListWorkflowExecutions mocks base method. +func (m *MockInterface) ListWorkflowExecutions(arg0 context.Context, arg1 *apiv1.ListWorkflowExecutionsRequest, arg2 ...yarpc.CallOption) (*apiv1.ListWorkflowExecutionsResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListWorkflowExecutions", varargs...) + ret0, _ := ret[0].(*apiv1.ListWorkflowExecutionsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListWorkflowExecutions indicates an expected call of ListWorkflowExecutions. +func (mr *MockInterfaceMockRecorder) ListWorkflowExecutions(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkflowExecutions", reflect.TypeOf((*MockInterface)(nil).ListWorkflowExecutions), varargs...) +} + +// PollForActivityTask mocks base method. +func (m *MockInterface) PollForActivityTask(arg0 context.Context, arg1 *apiv1.PollForActivityTaskRequest, arg2 ...yarpc.CallOption) (*apiv1.PollForActivityTaskResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PollForActivityTask", varargs...) + ret0, _ := ret[0].(*apiv1.PollForActivityTaskResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PollForActivityTask indicates an expected call of PollForActivityTask. +func (mr *MockInterfaceMockRecorder) PollForActivityTask(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PollForActivityTask", reflect.TypeOf((*MockInterface)(nil).PollForActivityTask), varargs...) +} + +// PollForDecisionTask mocks base method. +func (m *MockInterface) PollForDecisionTask(arg0 context.Context, arg1 *apiv1.PollForDecisionTaskRequest, arg2 ...yarpc.CallOption) (*apiv1.PollForDecisionTaskResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PollForDecisionTask", varargs...) + ret0, _ := ret[0].(*apiv1.PollForDecisionTaskResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PollForDecisionTask indicates an expected call of PollForDecisionTask. +func (mr *MockInterfaceMockRecorder) PollForDecisionTask(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PollForDecisionTask", reflect.TypeOf((*MockInterface)(nil).PollForDecisionTask), varargs...) +} + +// QueryWorkflow mocks base method. +func (m *MockInterface) QueryWorkflow(arg0 context.Context, arg1 *apiv1.QueryWorkflowRequest, arg2 ...yarpc.CallOption) (*apiv1.QueryWorkflowResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "QueryWorkflow", varargs...) + ret0, _ := ret[0].(*apiv1.QueryWorkflowResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryWorkflow indicates an expected call of QueryWorkflow. +func (mr *MockInterfaceMockRecorder) QueryWorkflow(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryWorkflow", reflect.TypeOf((*MockInterface)(nil).QueryWorkflow), varargs...) +} + +// RecordActivityTaskHeartbeat mocks base method. +func (m *MockInterface) RecordActivityTaskHeartbeat(arg0 context.Context, arg1 *apiv1.RecordActivityTaskHeartbeatRequest, arg2 ...yarpc.CallOption) (*apiv1.RecordActivityTaskHeartbeatResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RecordActivityTaskHeartbeat", varargs...) + ret0, _ := ret[0].(*apiv1.RecordActivityTaskHeartbeatResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RecordActivityTaskHeartbeat indicates an expected call of RecordActivityTaskHeartbeat. +func (mr *MockInterfaceMockRecorder) RecordActivityTaskHeartbeat(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordActivityTaskHeartbeat", reflect.TypeOf((*MockInterface)(nil).RecordActivityTaskHeartbeat), varargs...) +} + +// RecordActivityTaskHeartbeatByID mocks base method. +func (m *MockInterface) RecordActivityTaskHeartbeatByID(arg0 context.Context, arg1 *apiv1.RecordActivityTaskHeartbeatByIDRequest, arg2 ...yarpc.CallOption) (*apiv1.RecordActivityTaskHeartbeatByIDResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RecordActivityTaskHeartbeatByID", varargs...) + ret0, _ := ret[0].(*apiv1.RecordActivityTaskHeartbeatByIDResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RecordActivityTaskHeartbeatByID indicates an expected call of RecordActivityTaskHeartbeatByID. +func (mr *MockInterfaceMockRecorder) RecordActivityTaskHeartbeatByID(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordActivityTaskHeartbeatByID", reflect.TypeOf((*MockInterface)(nil).RecordActivityTaskHeartbeatByID), varargs...) +} + +// RegisterDomain mocks base method. +func (m *MockInterface) RegisterDomain(arg0 context.Context, arg1 *apiv1.RegisterDomainRequest, arg2 ...yarpc.CallOption) (*apiv1.RegisterDomainResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RegisterDomain", varargs...) + ret0, _ := ret[0].(*apiv1.RegisterDomainResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterDomain indicates an expected call of RegisterDomain. +func (mr *MockInterfaceMockRecorder) RegisterDomain(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterDomain", reflect.TypeOf((*MockInterface)(nil).RegisterDomain), varargs...) +} + +// RequestCancelWorkflowExecution mocks base method. +func (m *MockInterface) RequestCancelWorkflowExecution(arg0 context.Context, arg1 *apiv1.RequestCancelWorkflowExecutionRequest, arg2 ...yarpc.CallOption) (*apiv1.RequestCancelWorkflowExecutionResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RequestCancelWorkflowExecution", varargs...) + ret0, _ := ret[0].(*apiv1.RequestCancelWorkflowExecutionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestCancelWorkflowExecution indicates an expected call of RequestCancelWorkflowExecution. +func (mr *MockInterfaceMockRecorder) RequestCancelWorkflowExecution(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestCancelWorkflowExecution", reflect.TypeOf((*MockInterface)(nil).RequestCancelWorkflowExecution), varargs...) +} + +// ResetStickyTaskList mocks base method. +func (m *MockInterface) ResetStickyTaskList(arg0 context.Context, arg1 *apiv1.ResetStickyTaskListRequest, arg2 ...yarpc.CallOption) (*apiv1.ResetStickyTaskListResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResetStickyTaskList", varargs...) + ret0, _ := ret[0].(*apiv1.ResetStickyTaskListResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetStickyTaskList indicates an expected call of ResetStickyTaskList. +func (mr *MockInterfaceMockRecorder) ResetStickyTaskList(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetStickyTaskList", reflect.TypeOf((*MockInterface)(nil).ResetStickyTaskList), varargs...) +} + +// ResetWorkflowExecution mocks base method. +func (m *MockInterface) ResetWorkflowExecution(arg0 context.Context, arg1 *apiv1.ResetWorkflowExecutionRequest, arg2 ...yarpc.CallOption) (*apiv1.ResetWorkflowExecutionResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResetWorkflowExecution", varargs...) + ret0, _ := ret[0].(*apiv1.ResetWorkflowExecutionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetWorkflowExecution indicates an expected call of ResetWorkflowExecution. +func (mr *MockInterfaceMockRecorder) ResetWorkflowExecution(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetWorkflowExecution", reflect.TypeOf((*MockInterface)(nil).ResetWorkflowExecution), varargs...) +} + +// RespondActivityTaskCanceled mocks base method. +func (m *MockInterface) RespondActivityTaskCanceled(arg0 context.Context, arg1 *apiv1.RespondActivityTaskCanceledRequest, arg2 ...yarpc.CallOption) (*apiv1.RespondActivityTaskCanceledResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RespondActivityTaskCanceled", varargs...) + ret0, _ := ret[0].(*apiv1.RespondActivityTaskCanceledResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RespondActivityTaskCanceled indicates an expected call of RespondActivityTaskCanceled. +func (mr *MockInterfaceMockRecorder) RespondActivityTaskCanceled(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskCanceled", reflect.TypeOf((*MockInterface)(nil).RespondActivityTaskCanceled), varargs...) +} + +// RespondActivityTaskCanceledByID mocks base method. +func (m *MockInterface) RespondActivityTaskCanceledByID(arg0 context.Context, arg1 *apiv1.RespondActivityTaskCanceledByIDRequest, arg2 ...yarpc.CallOption) (*apiv1.RespondActivityTaskCanceledByIDResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RespondActivityTaskCanceledByID", varargs...) + ret0, _ := ret[0].(*apiv1.RespondActivityTaskCanceledByIDResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RespondActivityTaskCanceledByID indicates an expected call of RespondActivityTaskCanceledByID. +func (mr *MockInterfaceMockRecorder) RespondActivityTaskCanceledByID(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskCanceledByID", reflect.TypeOf((*MockInterface)(nil).RespondActivityTaskCanceledByID), varargs...) +} + +// RespondActivityTaskCompleted mocks base method. +func (m *MockInterface) RespondActivityTaskCompleted(arg0 context.Context, arg1 *apiv1.RespondActivityTaskCompletedRequest, arg2 ...yarpc.CallOption) (*apiv1.RespondActivityTaskCompletedResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RespondActivityTaskCompleted", varargs...) + ret0, _ := ret[0].(*apiv1.RespondActivityTaskCompletedResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RespondActivityTaskCompleted indicates an expected call of RespondActivityTaskCompleted. +func (mr *MockInterfaceMockRecorder) RespondActivityTaskCompleted(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskCompleted", reflect.TypeOf((*MockInterface)(nil).RespondActivityTaskCompleted), varargs...) +} + +// RespondActivityTaskCompletedByID mocks base method. +func (m *MockInterface) RespondActivityTaskCompletedByID(arg0 context.Context, arg1 *apiv1.RespondActivityTaskCompletedByIDRequest, arg2 ...yarpc.CallOption) (*apiv1.RespondActivityTaskCompletedByIDResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RespondActivityTaskCompletedByID", varargs...) + ret0, _ := ret[0].(*apiv1.RespondActivityTaskCompletedByIDResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RespondActivityTaskCompletedByID indicates an expected call of RespondActivityTaskCompletedByID. +func (mr *MockInterfaceMockRecorder) RespondActivityTaskCompletedByID(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskCompletedByID", reflect.TypeOf((*MockInterface)(nil).RespondActivityTaskCompletedByID), varargs...) +} + +// RespondActivityTaskFailed mocks base method. +func (m *MockInterface) RespondActivityTaskFailed(arg0 context.Context, arg1 *apiv1.RespondActivityTaskFailedRequest, arg2 ...yarpc.CallOption) (*apiv1.RespondActivityTaskFailedResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RespondActivityTaskFailed", varargs...) + ret0, _ := ret[0].(*apiv1.RespondActivityTaskFailedResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RespondActivityTaskFailed indicates an expected call of RespondActivityTaskFailed. +func (mr *MockInterfaceMockRecorder) RespondActivityTaskFailed(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskFailed", reflect.TypeOf((*MockInterface)(nil).RespondActivityTaskFailed), varargs...) +} + +// RespondActivityTaskFailedByID mocks base method. +func (m *MockInterface) RespondActivityTaskFailedByID(arg0 context.Context, arg1 *apiv1.RespondActivityTaskFailedByIDRequest, arg2 ...yarpc.CallOption) (*apiv1.RespondActivityTaskFailedByIDResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RespondActivityTaskFailedByID", varargs...) + ret0, _ := ret[0].(*apiv1.RespondActivityTaskFailedByIDResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RespondActivityTaskFailedByID indicates an expected call of RespondActivityTaskFailedByID. +func (mr *MockInterfaceMockRecorder) RespondActivityTaskFailedByID(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondActivityTaskFailedByID", reflect.TypeOf((*MockInterface)(nil).RespondActivityTaskFailedByID), varargs...) +} + +// RespondDecisionTaskCompleted mocks base method. +func (m *MockInterface) RespondDecisionTaskCompleted(arg0 context.Context, arg1 *apiv1.RespondDecisionTaskCompletedRequest, arg2 ...yarpc.CallOption) (*apiv1.RespondDecisionTaskCompletedResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RespondDecisionTaskCompleted", varargs...) + ret0, _ := ret[0].(*apiv1.RespondDecisionTaskCompletedResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RespondDecisionTaskCompleted indicates an expected call of RespondDecisionTaskCompleted. +func (mr *MockInterfaceMockRecorder) RespondDecisionTaskCompleted(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondDecisionTaskCompleted", reflect.TypeOf((*MockInterface)(nil).RespondDecisionTaskCompleted), varargs...) +} + +// RespondDecisionTaskFailed mocks base method. +func (m *MockInterface) RespondDecisionTaskFailed(arg0 context.Context, arg1 *apiv1.RespondDecisionTaskFailedRequest, arg2 ...yarpc.CallOption) (*apiv1.RespondDecisionTaskFailedResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RespondDecisionTaskFailed", varargs...) + ret0, _ := ret[0].(*apiv1.RespondDecisionTaskFailedResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RespondDecisionTaskFailed indicates an expected call of RespondDecisionTaskFailed. +func (mr *MockInterfaceMockRecorder) RespondDecisionTaskFailed(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondDecisionTaskFailed", reflect.TypeOf((*MockInterface)(nil).RespondDecisionTaskFailed), varargs...) +} + +// RespondQueryTaskCompleted mocks base method. +func (m *MockInterface) RespondQueryTaskCompleted(arg0 context.Context, arg1 *apiv1.RespondQueryTaskCompletedRequest, arg2 ...yarpc.CallOption) (*apiv1.RespondQueryTaskCompletedResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RespondQueryTaskCompleted", varargs...) + ret0, _ := ret[0].(*apiv1.RespondQueryTaskCompletedResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RespondQueryTaskCompleted indicates an expected call of RespondQueryTaskCompleted. +func (mr *MockInterfaceMockRecorder) RespondQueryTaskCompleted(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondQueryTaskCompleted", reflect.TypeOf((*MockInterface)(nil).RespondQueryTaskCompleted), varargs...) +} + +// ScanWorkflowExecutions mocks base method. +func (m *MockInterface) ScanWorkflowExecutions(arg0 context.Context, arg1 *apiv1.ScanWorkflowExecutionsRequest, arg2 ...yarpc.CallOption) (*apiv1.ScanWorkflowExecutionsResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ScanWorkflowExecutions", varargs...) + ret0, _ := ret[0].(*apiv1.ScanWorkflowExecutionsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ScanWorkflowExecutions indicates an expected call of ScanWorkflowExecutions. +func (mr *MockInterfaceMockRecorder) ScanWorkflowExecutions(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanWorkflowExecutions", reflect.TypeOf((*MockInterface)(nil).ScanWorkflowExecutions), varargs...) +} + +// SignalWithStartWorkflowExecution mocks base method. +func (m *MockInterface) SignalWithStartWorkflowExecution(arg0 context.Context, arg1 *apiv1.SignalWithStartWorkflowExecutionRequest, arg2 ...yarpc.CallOption) (*apiv1.SignalWithStartWorkflowExecutionResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SignalWithStartWorkflowExecution", varargs...) + ret0, _ := ret[0].(*apiv1.SignalWithStartWorkflowExecutionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SignalWithStartWorkflowExecution indicates an expected call of SignalWithStartWorkflowExecution. +func (mr *MockInterfaceMockRecorder) SignalWithStartWorkflowExecution(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignalWithStartWorkflowExecution", reflect.TypeOf((*MockInterface)(nil).SignalWithStartWorkflowExecution), varargs...) +} + +// SignalWorkflowExecution mocks base method. +func (m *MockInterface) SignalWorkflowExecution(arg0 context.Context, arg1 *apiv1.SignalWorkflowExecutionRequest, arg2 ...yarpc.CallOption) (*apiv1.SignalWorkflowExecutionResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SignalWorkflowExecution", varargs...) + ret0, _ := ret[0].(*apiv1.SignalWorkflowExecutionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SignalWorkflowExecution indicates an expected call of SignalWorkflowExecution. +func (mr *MockInterfaceMockRecorder) SignalWorkflowExecution(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignalWorkflowExecution", reflect.TypeOf((*MockInterface)(nil).SignalWorkflowExecution), varargs...) +} + +// StartWorkflowExecution mocks base method. +func (m *MockInterface) StartWorkflowExecution(arg0 context.Context, arg1 *apiv1.StartWorkflowExecutionRequest, arg2 ...yarpc.CallOption) (*apiv1.StartWorkflowExecutionResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartWorkflowExecution", varargs...) + ret0, _ := ret[0].(*apiv1.StartWorkflowExecutionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartWorkflowExecution indicates an expected call of StartWorkflowExecution. +func (mr *MockInterfaceMockRecorder) StartWorkflowExecution(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartWorkflowExecution", reflect.TypeOf((*MockInterface)(nil).StartWorkflowExecution), varargs...) +} + +// TerminateWorkflowExecution mocks base method. +func (m *MockInterface) TerminateWorkflowExecution(arg0 context.Context, arg1 *apiv1.TerminateWorkflowExecutionRequest, arg2 ...yarpc.CallOption) (*apiv1.TerminateWorkflowExecutionResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TerminateWorkflowExecution", varargs...) + ret0, _ := ret[0].(*apiv1.TerminateWorkflowExecutionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TerminateWorkflowExecution indicates an expected call of TerminateWorkflowExecution. +func (mr *MockInterfaceMockRecorder) TerminateWorkflowExecution(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateWorkflowExecution", reflect.TypeOf((*MockInterface)(nil).TerminateWorkflowExecution), varargs...) +} + +// UpdateDomain mocks base method. +func (m *MockInterface) UpdateDomain(arg0 context.Context, arg1 *apiv1.UpdateDomainRequest, arg2 ...yarpc.CallOption) (*apiv1.UpdateDomainResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateDomain", varargs...) + ret0, _ := ret[0].(*apiv1.UpdateDomainResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateDomain indicates an expected call of UpdateDomain. +func (mr *MockInterfaceMockRecorder) UpdateDomain(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDomain", reflect.TypeOf((*MockInterface)(nil).UpdateDomain), varargs...) +}