diff --git a/common/testing/mocksdk/client_mock.go b/common/testing/mocksdk/client_mock.go
new file mode 100644
index 00000000000..f775bc66bc4
--- /dev/null
+++ b/common/testing/mocksdk/client_mock.go
@@ -0,0 +1,470 @@
+// The MIT License
+//
+// Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
+//
+// Copyright (c) 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: go.temporal.io/sdk/client (interfaces: Client)
+
+// Package mocksdk is a generated GoMock package.
+package mocksdk
+
+import (
+	context "context"
+	reflect "reflect"
+
+	gomock "github.com/golang/mock/gomock"
+	enums "go.temporal.io/api/enums/v1"
+	workflowservice "go.temporal.io/api/workflowservice/v1"
+	client "go.temporal.io/sdk/client"
+	converter "go.temporal.io/sdk/converter"
+)
+
+// MockClient is a mock of Client interface.
+type MockClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockClientMockRecorder
+}
+
+// MockClientMockRecorder is the mock recorder for MockClient.
+type MockClientMockRecorder struct {
+	mock *MockClient
+}
+
+// NewMockClient creates a new mock instance.
+func NewMockClient(ctrl *gomock.Controller) *MockClient {
+	mock := &MockClient{ctrl: ctrl}
+	mock.recorder = &MockClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockClient) EXPECT() *MockClientMockRecorder {
+	return m.recorder
+}
+
+// CancelWorkflow mocks base method.
+func (m *MockClient) CancelWorkflow(arg0 context.Context, arg1, arg2 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CancelWorkflow", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CancelWorkflow indicates an expected call of CancelWorkflow.
+func (mr *MockClientMockRecorder) CancelWorkflow(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelWorkflow", reflect.TypeOf((*MockClient)(nil).CancelWorkflow), arg0, arg1, arg2)
+}
+
+// CheckHealth mocks base method.
+func (m *MockClient) CheckHealth(arg0 context.Context, arg1 *client.CheckHealthRequest) (*client.CheckHealthResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CheckHealth", arg0, arg1)
+	ret0, _ := ret[0].(*client.CheckHealthResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CheckHealth indicates an expected call of CheckHealth.
+func (mr *MockClientMockRecorder) CheckHealth(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckHealth", reflect.TypeOf((*MockClient)(nil).CheckHealth), arg0, arg1)
+}
+
+// Close mocks base method.
+func (m *MockClient) Close() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Close")
+}
+
+// Close indicates an expected call of Close.
+func (mr *MockClientMockRecorder) Close() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClient)(nil).Close))
+}
+
+// CompleteActivity mocks base method.
+func (m *MockClient) CompleteActivity(arg0 context.Context, arg1 []byte, arg2 interface{}, arg3 error) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CompleteActivity", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CompleteActivity indicates an expected call of CompleteActivity.
+func (mr *MockClientMockRecorder) CompleteActivity(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteActivity", reflect.TypeOf((*MockClient)(nil).CompleteActivity), arg0, arg1, arg2, arg3)
+}
+
+// CompleteActivityByID mocks base method.
+func (m *MockClient) CompleteActivityByID(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 interface{}, arg6 error) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CompleteActivityByID", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CompleteActivityByID indicates an expected call of CompleteActivityByID.
+func (mr *MockClientMockRecorder) CompleteActivityByID(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteActivityByID", reflect.TypeOf((*MockClient)(nil).CompleteActivityByID), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+}
+
+// CountWorkflow mocks base method.
+func (m *MockClient) CountWorkflow(arg0 context.Context, arg1 *workflowservice.CountWorkflowExecutionsRequest) (*workflowservice.CountWorkflowExecutionsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CountWorkflow", arg0, arg1)
+	ret0, _ := ret[0].(*workflowservice.CountWorkflowExecutionsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CountWorkflow indicates an expected call of CountWorkflow.
+func (mr *MockClientMockRecorder) CountWorkflow(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountWorkflow", reflect.TypeOf((*MockClient)(nil).CountWorkflow), arg0, arg1)
+}
+
+// DescribeTaskQueue mocks base method.
+func (m *MockClient) DescribeTaskQueue(arg0 context.Context, arg1 string, arg2 enums.TaskQueueType) (*workflowservice.DescribeTaskQueueResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeTaskQueue", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*workflowservice.DescribeTaskQueueResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeTaskQueue indicates an expected call of DescribeTaskQueue.
+func (mr *MockClientMockRecorder) DescribeTaskQueue(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTaskQueue", reflect.TypeOf((*MockClient)(nil).DescribeTaskQueue), arg0, arg1, arg2)
+}
+
+// DescribeWorkflowExecution mocks base method.
+func (m *MockClient) DescribeWorkflowExecution(arg0 context.Context, arg1, arg2 string) (*workflowservice.DescribeWorkflowExecutionResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeWorkflowExecution", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*workflowservice.DescribeWorkflowExecutionResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeWorkflowExecution indicates an expected call of DescribeWorkflowExecution.
+func (mr *MockClientMockRecorder) DescribeWorkflowExecution(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeWorkflowExecution", reflect.TypeOf((*MockClient)(nil).DescribeWorkflowExecution), arg0, arg1, arg2)
+}
+
+// ExecuteWorkflow mocks base method.
+func (m *MockClient) ExecuteWorkflow(arg0 context.Context, arg1 client.StartWorkflowOptions, arg2 interface{}, arg3 ...interface{}) (client.WorkflowRun, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ExecuteWorkflow", varargs...)
+	ret0, _ := ret[0].(client.WorkflowRun)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExecuteWorkflow indicates an expected call of ExecuteWorkflow.
+func (mr *MockClientMockRecorder) ExecuteWorkflow(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteWorkflow", reflect.TypeOf((*MockClient)(nil).ExecuteWorkflow), varargs...)
+}
+
+// GetSearchAttributes mocks base method.
+func (m *MockClient) GetSearchAttributes(arg0 context.Context) (*workflowservice.GetSearchAttributesResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSearchAttributes", arg0)
+	ret0, _ := ret[0].(*workflowservice.GetSearchAttributesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSearchAttributes indicates an expected call of GetSearchAttributes.
+func (mr *MockClientMockRecorder) GetSearchAttributes(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSearchAttributes", reflect.TypeOf((*MockClient)(nil).GetSearchAttributes), arg0)
+}
+
+// GetWorkflow mocks base method.
+func (m *MockClient) GetWorkflow(arg0 context.Context, arg1, arg2 string) client.WorkflowRun {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetWorkflow", arg0, arg1, arg2)
+	ret0, _ := ret[0].(client.WorkflowRun)
+	return ret0
+}
+
+// GetWorkflow indicates an expected call of GetWorkflow.
+func (mr *MockClientMockRecorder) GetWorkflow(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflow", reflect.TypeOf((*MockClient)(nil).GetWorkflow), arg0, arg1, arg2)
+}
+
+// GetWorkflowHistory mocks base method.
+func (m *MockClient) GetWorkflowHistory(arg0 context.Context, arg1, arg2 string, arg3 bool, arg4 enums.HistoryEventFilterType) client.HistoryEventIterator {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetWorkflowHistory", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(client.HistoryEventIterator)
+	return ret0
+}
+
+// GetWorkflowHistory indicates an expected call of GetWorkflowHistory.
+func (mr *MockClientMockRecorder) GetWorkflowHistory(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowHistory", reflect.TypeOf((*MockClient)(nil).GetWorkflowHistory), arg0, arg1, arg2, arg3, arg4)
+}
+
+// ListArchivedWorkflow mocks base method.
+func (m *MockClient) ListArchivedWorkflow(arg0 context.Context, arg1 *workflowservice.ListArchivedWorkflowExecutionsRequest) (*workflowservice.ListArchivedWorkflowExecutionsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListArchivedWorkflow", arg0, arg1)
+	ret0, _ := ret[0].(*workflowservice.ListArchivedWorkflowExecutionsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListArchivedWorkflow indicates an expected call of ListArchivedWorkflow.
+func (mr *MockClientMockRecorder) ListArchivedWorkflow(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListArchivedWorkflow", reflect.TypeOf((*MockClient)(nil).ListArchivedWorkflow), arg0, arg1)
+}
+
+// ListClosedWorkflow mocks base method.
+func (m *MockClient) ListClosedWorkflow(arg0 context.Context, arg1 *workflowservice.ListClosedWorkflowExecutionsRequest) (*workflowservice.ListClosedWorkflowExecutionsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListClosedWorkflow", arg0, arg1)
+	ret0, _ := ret[0].(*workflowservice.ListClosedWorkflowExecutionsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListClosedWorkflow indicates an expected call of ListClosedWorkflow.
+func (mr *MockClientMockRecorder) ListClosedWorkflow(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClosedWorkflow", reflect.TypeOf((*MockClient)(nil).ListClosedWorkflow), arg0, arg1)
+}
+
+// ListOpenWorkflow mocks base method.
+func (m *MockClient) ListOpenWorkflow(arg0 context.Context, arg1 *workflowservice.ListOpenWorkflowExecutionsRequest) (*workflowservice.ListOpenWorkflowExecutionsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListOpenWorkflow", arg0, arg1)
+	ret0, _ := ret[0].(*workflowservice.ListOpenWorkflowExecutionsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListOpenWorkflow indicates an expected call of ListOpenWorkflow.
+func (mr *MockClientMockRecorder) ListOpenWorkflow(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpenWorkflow", reflect.TypeOf((*MockClient)(nil).ListOpenWorkflow), arg0, arg1)
+}
+
+// ListWorkflow mocks base method.
+func (m *MockClient) ListWorkflow(arg0 context.Context, arg1 *workflowservice.ListWorkflowExecutionsRequest) (*workflowservice.ListWorkflowExecutionsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListWorkflow", arg0, arg1)
+	ret0, _ := ret[0].(*workflowservice.ListWorkflowExecutionsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListWorkflow indicates an expected call of ListWorkflow.
+func (mr *MockClientMockRecorder) ListWorkflow(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkflow", reflect.TypeOf((*MockClient)(nil).ListWorkflow), arg0, arg1)
+}
+
+// QueryWorkflow mocks base method.
+func (m *MockClient) QueryWorkflow(arg0 context.Context, arg1, arg2, arg3 string, arg4 ...interface{}) (converter.EncodedValue, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2, arg3}
+	for _, a := range arg4 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "QueryWorkflow", varargs...)
+	ret0, _ := ret[0].(converter.EncodedValue)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// QueryWorkflow indicates an expected call of QueryWorkflow.
+func (mr *MockClientMockRecorder) QueryWorkflow(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryWorkflow", reflect.TypeOf((*MockClient)(nil).QueryWorkflow), varargs...)
+}
+
+// QueryWorkflowWithOptions mocks base method.
+func (m *MockClient) QueryWorkflowWithOptions(arg0 context.Context, arg1 *client.QueryWorkflowWithOptionsRequest) (*client.QueryWorkflowWithOptionsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "QueryWorkflowWithOptions", arg0, arg1)
+	ret0, _ := ret[0].(*client.QueryWorkflowWithOptionsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// QueryWorkflowWithOptions indicates an expected call of QueryWorkflowWithOptions.
+func (mr *MockClientMockRecorder) QueryWorkflowWithOptions(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryWorkflowWithOptions", reflect.TypeOf((*MockClient)(nil).QueryWorkflowWithOptions), arg0, arg1)
+}
+
+// RecordActivityHeartbeat mocks base method.
+func (m *MockClient) RecordActivityHeartbeat(arg0 context.Context, arg1 []byte, arg2 ...interface{}) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RecordActivityHeartbeat", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RecordActivityHeartbeat indicates an expected call of RecordActivityHeartbeat.
+func (mr *MockClientMockRecorder) RecordActivityHeartbeat(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, "RecordActivityHeartbeat", reflect.TypeOf((*MockClient)(nil).RecordActivityHeartbeat), varargs...)
+}
+
+// RecordActivityHeartbeatByID mocks base method.
+func (m *MockClient) RecordActivityHeartbeatByID(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 ...interface{}) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2, arg3, arg4}
+	for _, a := range arg5 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RecordActivityHeartbeatByID", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RecordActivityHeartbeatByID indicates an expected call of RecordActivityHeartbeatByID.
+func (mr *MockClientMockRecorder) RecordActivityHeartbeatByID(arg0, arg1, arg2, arg3, arg4 interface{}, arg5 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2, arg3, arg4}, arg5...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordActivityHeartbeatByID", reflect.TypeOf((*MockClient)(nil).RecordActivityHeartbeatByID), varargs...)
+}
+
+// ResetWorkflowExecution mocks base method.
+func (m *MockClient) 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 *MockClientMockRecorder) ResetWorkflowExecution(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetWorkflowExecution", reflect.TypeOf((*MockClient)(nil).ResetWorkflowExecution), arg0, arg1)
+}
+
+// ScanWorkflow mocks base method.
+func (m *MockClient) ScanWorkflow(arg0 context.Context, arg1 *workflowservice.ScanWorkflowExecutionsRequest) (*workflowservice.ScanWorkflowExecutionsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ScanWorkflow", arg0, arg1)
+	ret0, _ := ret[0].(*workflowservice.ScanWorkflowExecutionsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ScanWorkflow indicates an expected call of ScanWorkflow.
+func (mr *MockClientMockRecorder) ScanWorkflow(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanWorkflow", reflect.TypeOf((*MockClient)(nil).ScanWorkflow), arg0, arg1)
+}
+
+// SignalWithStartWorkflow mocks base method.
+func (m *MockClient) SignalWithStartWorkflow(arg0 context.Context, arg1, arg2 string, arg3 interface{}, arg4 client.StartWorkflowOptions, arg5 interface{}, arg6 ...interface{}) (client.WorkflowRun, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2, arg3, arg4, arg5}
+	for _, a := range arg6 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SignalWithStartWorkflow", varargs...)
+	ret0, _ := ret[0].(client.WorkflowRun)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SignalWithStartWorkflow indicates an expected call of SignalWithStartWorkflow.
+func (mr *MockClientMockRecorder) SignalWithStartWorkflow(arg0, arg1, arg2, arg3, arg4, arg5 interface{}, arg6 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5}, arg6...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignalWithStartWorkflow", reflect.TypeOf((*MockClient)(nil).SignalWithStartWorkflow), varargs...)
+}
+
+// SignalWorkflow mocks base method.
+func (m *MockClient) SignalWorkflow(arg0 context.Context, arg1, arg2, arg3 string, arg4 interface{}) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SignalWorkflow", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SignalWorkflow indicates an expected call of SignalWorkflow.
+func (mr *MockClientMockRecorder) SignalWorkflow(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignalWorkflow", reflect.TypeOf((*MockClient)(nil).SignalWorkflow), arg0, arg1, arg2, arg3, arg4)
+}
+
+// TerminateWorkflow mocks base method.
+func (m *MockClient) TerminateWorkflow(arg0 context.Context, arg1, arg2, arg3 string, arg4 ...interface{}) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2, arg3}
+	for _, a := range arg4 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "TerminateWorkflow", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// TerminateWorkflow indicates an expected call of TerminateWorkflow.
+func (mr *MockClientMockRecorder) TerminateWorkflow(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateWorkflow", reflect.TypeOf((*MockClient)(nil).TerminateWorkflow), varargs...)
+}
+
+// WorkflowService mocks base method.
+func (m *MockClient) WorkflowService() workflowservice.WorkflowServiceClient {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WorkflowService")
+	ret0, _ := ret[0].(workflowservice.WorkflowServiceClient)
+	return ret0
+}
+
+// WorkflowService indicates an expected call of WorkflowService.
+func (mr *MockClientMockRecorder) WorkflowService() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkflowService", reflect.TypeOf((*MockClient)(nil).WorkflowService))
+}
diff --git a/common/testing/mocksdk/generate.go b/common/testing/mocksdk/generate.go
new file mode 100644
index 00000000000..e7bee23781f
--- /dev/null
+++ b/common/testing/mocksdk/generate.go
@@ -0,0 +1,27 @@
+// The MIT License
+//
+// Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
+//
+// Copyright (c) 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.
+
+//go:generate ./generate.sh
+
+package mocksdk
diff --git a/common/testing/mocksdk/generate.sh b/common/testing/mocksdk/generate.sh
new file mode 100755
index 00000000000..a0e6ea3f0b1
--- /dev/null
+++ b/common/testing/mocksdk/generate.sh
@@ -0,0 +1,19 @@
+#!/bin/sh
+# shellcheck disable=SC1004
+# The only portable way to embed a newline in sed is with a literal
+# backslash+newline, but shellcheck doesn't like it.
+
+# These mocks need to be manually fixed up after generation because gomock
+# uses the types in the internal package instead of the public type aliases.
+mockgen -copyright_file ../../../LICENSE -package "$GOPACKAGE" go.temporal.io/sdk/client Client | sed \
+	-e 's,\<internal\>,client,g' \
+	-e '/"go.temporal.io\/sdk\/converter"/d' \
+	-e 's,client "go.temporal.io/sdk/client",client "go.temporal.io/sdk/client"\
+	converter "go.temporal.io/sdk/converter",' \
+	> client_mock.go
+mockgen -copyright_file ../../../LICENSE -package "$GOPACKAGE" go.temporal.io/sdk/worker Worker | sed \
+	-e 's,internal.RegisterWorkflowOptions,workflow.RegisterOptions,g' \
+	-e 's,internal.RegisterActivityOptions,activity.RegisterOptions,g' \
+	-e 's,internal "go.temporal.io/sdk/internal",activity "go.temporal.io/sdk/activity"\
+	workflow "go.temporal.io/sdk/workflow",' \
+	> worker_mock.go
diff --git a/common/testing/mocksdk/worker_mock.go b/common/testing/mocksdk/worker_mock.go
new file mode 100644
index 00000000000..57368fa98e4
--- /dev/null
+++ b/common/testing/mocksdk/worker_mock.go
@@ -0,0 +1,148 @@
+// The MIT License
+//
+// Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
+//
+// Copyright (c) 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: go.temporal.io/sdk/worker (interfaces: Worker)
+
+// Package mocksdk is a generated GoMock package.
+package mocksdk
+
+import (
+	reflect "reflect"
+
+	gomock "github.com/golang/mock/gomock"
+	activity "go.temporal.io/sdk/activity"
+	workflow "go.temporal.io/sdk/workflow"
+)
+
+// MockWorker is a mock of Worker interface.
+type MockWorker struct {
+	ctrl     *gomock.Controller
+	recorder *MockWorkerMockRecorder
+}
+
+// MockWorkerMockRecorder is the mock recorder for MockWorker.
+type MockWorkerMockRecorder struct {
+	mock *MockWorker
+}
+
+// NewMockWorker creates a new mock instance.
+func NewMockWorker(ctrl *gomock.Controller) *MockWorker {
+	mock := &MockWorker{ctrl: ctrl}
+	mock.recorder = &MockWorkerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockWorker) EXPECT() *MockWorkerMockRecorder {
+	return m.recorder
+}
+
+// RegisterActivity mocks base method.
+func (m *MockWorker) RegisterActivity(arg0 interface{}) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RegisterActivity", arg0)
+}
+
+// RegisterActivity indicates an expected call of RegisterActivity.
+func (mr *MockWorkerMockRecorder) RegisterActivity(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActivity", reflect.TypeOf((*MockWorker)(nil).RegisterActivity), arg0)
+}
+
+// RegisterActivityWithOptions mocks base method.
+func (m *MockWorker) RegisterActivityWithOptions(arg0 interface{}, arg1 activity.RegisterOptions) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RegisterActivityWithOptions", arg0, arg1)
+}
+
+// RegisterActivityWithOptions indicates an expected call of RegisterActivityWithOptions.
+func (mr *MockWorkerMockRecorder) RegisterActivityWithOptions(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActivityWithOptions", reflect.TypeOf((*MockWorker)(nil).RegisterActivityWithOptions), arg0, arg1)
+}
+
+// RegisterWorkflow mocks base method.
+func (m *MockWorker) RegisterWorkflow(arg0 interface{}) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RegisterWorkflow", arg0)
+}
+
+// RegisterWorkflow indicates an expected call of RegisterWorkflow.
+func (mr *MockWorkerMockRecorder) RegisterWorkflow(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorkflow", reflect.TypeOf((*MockWorker)(nil).RegisterWorkflow), arg0)
+}
+
+// RegisterWorkflowWithOptions mocks base method.
+func (m *MockWorker) RegisterWorkflowWithOptions(arg0 interface{}, arg1 workflow.RegisterOptions) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RegisterWorkflowWithOptions", arg0, arg1)
+}
+
+// RegisterWorkflowWithOptions indicates an expected call of RegisterWorkflowWithOptions.
+func (mr *MockWorkerMockRecorder) RegisterWorkflowWithOptions(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorkflowWithOptions", reflect.TypeOf((*MockWorker)(nil).RegisterWorkflowWithOptions), arg0, arg1)
+}
+
+// Run mocks base method.
+func (m *MockWorker) Run(arg0 <-chan interface{}) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Run", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Run indicates an expected call of Run.
+func (mr *MockWorkerMockRecorder) Run(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockWorker)(nil).Run), arg0)
+}
+
+// Start mocks base method.
+func (m *MockWorker) Start() error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Start")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Start indicates an expected call of Start.
+func (mr *MockWorkerMockRecorder) Start() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockWorker)(nil).Start))
+}
+
+// Stop mocks base method.
+func (m *MockWorker) Stop() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Stop")
+}
+
+// Stop indicates an expected call of Stop.
+func (mr *MockWorkerMockRecorder) Stop() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockWorker)(nil).Stop))
+}