mocks

package
v0.1.7 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 21, 2025 License: MIT Imports: 14 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Agent 

type Agent struct {
	mock.Mock
}

Agent is an autogenerated mock type for the Agent type

func NewAgent 

func NewAgent(t interface {
	mock.TestingT
	Cleanup(func())
},
) *Agent

NewAgent creates a new instance of Agent. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*Agent) EXPECT 

func (_m *Agent) EXPECT() *Agent_Expecter

func (*Agent) Instructions 

func (_m *Agent) Instructions() string

Instructions provides a mock function with no fields

func (*Agent) Model 

func (_m *Agent) Model() api.Model

Model provides a mock function with no fields

func (*Agent) Name 

func (_m *Agent) Name() string

Name provides a mock function with no fields

func (*Agent) ParallelToolCalls 

func (_m *Agent) ParallelToolCalls() bool

ParallelToolCalls provides a mock function with no fields

func (*Agent) RenderInstructions 

func (_m *Agent) RenderInstructions(_a0 types.ContextVars) (string, error)

RenderInstructions provides a mock function with given fields: _a0

func (*Agent) Tools 

func (_m *Agent) Tools() []tool.Definition

Tools provides a mock function with no fields

type Agent_Expecter 

type Agent_Expecter struct {
	// contains filtered or unexported fields
}

func (*Agent_Expecter) Instructions 

func (_e *Agent_Expecter) Instructions() *Agent_Instructions_Call

Instructions is a helper method to define mock.On call

func (*Agent_Expecter) Model 

func (_e *Agent_Expecter) Model() *Agent_Model_Call

Model is a helper method to define mock.On call

func (*Agent_Expecter) Name 

func (_e *Agent_Expecter) Name() *Agent_Name_Call

Name is a helper method to define mock.On call

func (*Agent_Expecter) ParallelToolCalls 

func (_e *Agent_Expecter) ParallelToolCalls() *Agent_ParallelToolCalls_Call

ParallelToolCalls is a helper method to define mock.On call

func (*Agent_Expecter) RenderInstructions 

func (_e *Agent_Expecter) RenderInstructions(_a0 interface{}) *Agent_RenderInstructions_Call

RenderInstructions is a helper method to define mock.On call

  • _a0 types.ContextVars

func (*Agent_Expecter) Tools 

func (_e *Agent_Expecter) Tools() *Agent_Tools_Call

Tools is a helper method to define mock.On call

type Agent_Instructions_Call 

type Agent_Instructions_Call struct {
	*mock.Call
}

Agent_Instructions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Instructions'

func (*Agent_Instructions_Call) Return 

func (_c *Agent_Instructions_Call) Return(_a0 string) *Agent_Instructions_Call

func (*Agent_Instructions_Call) Run 

func (_c *Agent_Instructions_Call) Run(run func()) *Agent_Instructions_Call

func (*Agent_Instructions_Call) RunAndReturn 

func (_c *Agent_Instructions_Call) RunAndReturn(run func() string) *Agent_Instructions_Call

type Agent_Model_Call 

type Agent_Model_Call struct {
	*mock.Call
}

Agent_Model_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Model'

func (*Agent_Model_Call) Return 

func (_c *Agent_Model_Call) Return(_a0 api.Model) *Agent_Model_Call

func (*Agent_Model_Call) Run 

func (_c *Agent_Model_Call) Run(run func()) *Agent_Model_Call

func (*Agent_Model_Call) RunAndReturn 

func (_c *Agent_Model_Call) RunAndReturn(run func() api.Model) *Agent_Model_Call

type Agent_Name_Call 

type Agent_Name_Call struct {
	*mock.Call
}

Agent_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name'

func (*Agent_Name_Call) Return 

func (_c *Agent_Name_Call) Return(_a0 string) *Agent_Name_Call

func (*Agent_Name_Call) Run 

func (_c *Agent_Name_Call) Run(run func()) *Agent_Name_Call

func (*Agent_Name_Call) RunAndReturn 

func (_c *Agent_Name_Call) RunAndReturn(run func() string) *Agent_Name_Call

type Agent_ParallelToolCalls_Call 

type Agent_ParallelToolCalls_Call struct {
	*mock.Call
}

Agent_ParallelToolCalls_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ParallelToolCalls'

func (*Agent_ParallelToolCalls_Call) Return 

func (_c *Agent_ParallelToolCalls_Call) Return(_a0 bool) *Agent_ParallelToolCalls_Call

func (*Agent_ParallelToolCalls_Call) Run 

func (_c *Agent_ParallelToolCalls_Call) Run(run func()) *Agent_ParallelToolCalls_Call

func (*Agent_ParallelToolCalls_Call) RunAndReturn 

func (_c *Agent_ParallelToolCalls_Call) RunAndReturn(run func() bool) *Agent_ParallelToolCalls_Call

type Agent_RenderInstructions_Call 

type Agent_RenderInstructions_Call struct {
	*mock.Call
}

Agent_RenderInstructions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenderInstructions'

func (*Agent_RenderInstructions_Call) Return 

func (_c *Agent_RenderInstructions_Call) Return(_a0 string, _a1 error) *Agent_RenderInstructions_Call

func (*Agent_RenderInstructions_Call) Run 

func (_c *Agent_RenderInstructions_Call) Run(run func(_a0 types.ContextVars)) *Agent_RenderInstructions_Call

func (*Agent_RenderInstructions_Call) RunAndReturn 

func (_c *Agent_RenderInstructions_Call) RunAndReturn(run func(types.ContextVars) (string, error)) *Agent_RenderInstructions_Call

type Agent_Tools_Call 

type Agent_Tools_Call struct {
	*mock.Call
}

Agent_Tools_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Tools'

func (*Agent_Tools_Call) Return 

func (_c *Agent_Tools_Call) Return(_a0 []tool.Definition) *Agent_Tools_Call

func (*Agent_Tools_Call) Run 

func (_c *Agent_Tools_Call) Run(run func()) *Agent_Tools_Call

func (*Agent_Tools_Call) RunAndReturn 

func (_c *Agent_Tools_Call) RunAndReturn(run func() []tool.Definition) *Agent_Tools_Call

type Broker 

type Broker struct {
	mock.Mock
}

Broker is an autogenerated mock type for the Broker type

func NewBroker 

func NewBroker(t interface {
	mock.TestingT
	Cleanup(func())
},
) *Broker

NewBroker creates a new instance of Broker. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*Broker) EXPECT 

func (_m *Broker) EXPECT() *Broker_Expecter

func (*Broker) Topic 

func (_m *Broker) Topic(_a0 context.Context, _a1 string) broker.Topic

Topic provides a mock function with given fields: _a0, _a1

type Broker_Expecter 

type Broker_Expecter struct {
	// contains filtered or unexported fields
}

func (*Broker_Expecter) Topic 

func (_e *Broker_Expecter) Topic(_a0 interface{}, _a1 interface{}) *Broker_Topic_Call

Topic is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 string

type Broker_Topic_Call 

type Broker_Topic_Call struct {
	*mock.Call
}

Broker_Topic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Topic'

func (*Broker_Topic_Call) Return 

func (_c *Broker_Topic_Call) Return(_a0 broker.Topic) *Broker_Topic_Call

func (*Broker_Topic_Call) Run 

func (_c *Broker_Topic_Call) Run(run func(_a0 context.Context, _a1 string)) *Broker_Topic_Call

func (*Broker_Topic_Call) RunAndReturn 

func (_c *Broker_Topic_Call) RunAndReturn(run func(context.Context, string) broker.Topic) *Broker_Topic_Call

type Client 

type Client struct {
	mock.Mock
}

Client is an autogenerated mock type for the Client type

func NewClient 

func NewClient(t interface {
	mock.TestingT
	Cleanup(func())
},
) *Client

NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*Client) CancelWorkflow 

func (_m *Client) CancelWorkflow(ctx context.Context, workflowID string, runID string) error

CancelWorkflow provides a mock function with given fields: ctx, workflowID, runID

func (*Client) CheckHealth 

func (_m *Client) CheckHealth(ctx context.Context, request *client.CheckHealthRequest) (*client.CheckHealthResponse, error)

CheckHealth provides a mock function with given fields: ctx, request

func (*Client) Close 

func (_m *Client) Close()

Close provides a mock function with no fields

func (*Client) CompleteActivity 

func (_m *Client) CompleteActivity(ctx context.Context, taskToken []byte, result interface{}, err error) error

CompleteActivity provides a mock function with given fields: ctx, taskToken, result, err

func (*Client) CompleteActivityByID 

func (_m *Client) CompleteActivityByID(ctx context.Context, namespace string, workflowID string, runID string, activityID string, result interface{}, err error) error

CompleteActivityByID provides a mock function with given fields: ctx, namespace, workflowID, runID, activityID, result, err

func (*Client) CountWorkflow 

func (_m *Client) CountWorkflow(ctx context.Context, request *workflowservice.CountWorkflowExecutionsRequest) (*workflowservice.CountWorkflowExecutionsResponse, error)

CountWorkflow provides a mock function with given fields: ctx, request

func (*Client) DescribeTaskQueue 

func (_m *Client) DescribeTaskQueue(ctx context.Context, taskqueue string, taskqueueType enums.TaskQueueType) (*workflowservice.DescribeTaskQueueResponse, error)

DescribeTaskQueue provides a mock function with given fields: ctx, taskqueue, taskqueueType

func (*Client) DescribeTaskQueueEnhanced 

func (_m *Client) DescribeTaskQueueEnhanced(ctx context.Context, options client.DescribeTaskQueueEnhancedOptions) (client.TaskQueueDescription, error)

DescribeTaskQueueEnhanced provides a mock function with given fields: ctx, options

func (*Client) DescribeWorkflowExecution 

func (_m *Client) DescribeWorkflowExecution(ctx context.Context, workflowID string, runID string) (*workflowservice.DescribeWorkflowExecutionResponse, error)

DescribeWorkflowExecution provides a mock function with given fields: ctx, workflowID, runID

func (*Client) EXPECT 

func (_m *Client) EXPECT() *Client_Expecter

func (*Client) ExecuteWorkflow 

func (_m *Client) ExecuteWorkflow(ctx context.Context, options client.StartWorkflowOptions, workflow interface{}, args ...interface{}) (client.WorkflowRun, error)

ExecuteWorkflow provides a mock function with given fields: ctx, options, workflow, args

func (*Client) GetSearchAttributes 

func (_m *Client) GetSearchAttributes(ctx context.Context) (*workflowservice.GetSearchAttributesResponse, error)

GetSearchAttributes provides a mock function with given fields: ctx

func (*Client) GetWorkerBuildIdCompatibility 

func (_m *Client) GetWorkerBuildIdCompatibility(ctx context.Context, options *client.GetWorkerBuildIdCompatibilityOptions) (*client.WorkerBuildIDVersionSets, error)

GetWorkerBuildIdCompatibility provides a mock function with given fields: ctx, options

func (*Client) GetWorkerTaskReachability 

func (_m *Client) GetWorkerTaskReachability(ctx context.Context, options *client.GetWorkerTaskReachabilityOptions) (*client.WorkerTaskReachability, error)

GetWorkerTaskReachability provides a mock function with given fields: ctx, options

func (*Client) GetWorkerVersioningRules 

func (_m *Client) GetWorkerVersioningRules(ctx context.Context, options client.GetWorkerVersioningOptions) (*client.WorkerVersioningRules, error)

GetWorkerVersioningRules provides a mock function with given fields: ctx, options

func (*Client) GetWorkflow 

func (_m *Client) GetWorkflow(ctx context.Context, workflowID string, runID string) client.WorkflowRun

GetWorkflow provides a mock function with given fields: ctx, workflowID, runID

func (*Client) GetWorkflowHistory 

func (_m *Client) GetWorkflowHistory(ctx context.Context, workflowID string, runID string, isLongPoll bool, filterType enums.HistoryEventFilterType) client.HistoryEventIterator

GetWorkflowHistory provides a mock function with given fields: ctx, workflowID, runID, isLongPoll, filterType

func (*Client) GetWorkflowUpdateHandle 

func (_m *Client) GetWorkflowUpdateHandle(ref client.GetWorkflowUpdateHandleOptions) client.WorkflowUpdateHandle

GetWorkflowUpdateHandle provides a mock function with given fields: ref

func (*Client) ListArchivedWorkflow 

func (_m *Client) ListArchivedWorkflow(ctx context.Context, request *workflowservice.ListArchivedWorkflowExecutionsRequest) (*workflowservice.ListArchivedWorkflowExecutionsResponse, error)

ListArchivedWorkflow provides a mock function with given fields: ctx, request

func (*Client) ListClosedWorkflow 

func (_m *Client) ListClosedWorkflow(ctx context.Context, request *workflowservice.ListClosedWorkflowExecutionsRequest) (*workflowservice.ListClosedWorkflowExecutionsResponse, error)

ListClosedWorkflow provides a mock function with given fields: ctx, request

func (*Client) ListOpenWorkflow 

func (_m *Client) ListOpenWorkflow(ctx context.Context, request *workflowservice.ListOpenWorkflowExecutionsRequest) (*workflowservice.ListOpenWorkflowExecutionsResponse, error)

ListOpenWorkflow provides a mock function with given fields: ctx, request

func (*Client) ListWorkflow 

func (_m *Client) ListWorkflow(ctx context.Context, request *workflowservice.ListWorkflowExecutionsRequest) (*workflowservice.ListWorkflowExecutionsResponse, error)

ListWorkflow provides a mock function with given fields: ctx, request

func (*Client) NewWithStartWorkflowOperation 

func (_m *Client) NewWithStartWorkflowOperation(options client.StartWorkflowOptions, workflow interface{}, args ...interface{}) client.WithStartWorkflowOperation

NewWithStartWorkflowOperation provides a mock function with given fields: options, workflow, args

func (*Client) OperatorService 

func (_m *Client) OperatorService() operatorservice.OperatorServiceClient

OperatorService provides a mock function with no fields

func (*Client) QueryWorkflow 

func (_m *Client) QueryWorkflow(ctx context.Context, workflowID string, runID string, queryType string, args ...interface{}) (converter.EncodedValue, error)

QueryWorkflow provides a mock function with given fields: ctx, workflowID, runID, queryType, args

func (*Client) QueryWorkflowWithOptions 

func (_m *Client) QueryWorkflowWithOptions(ctx context.Context, request *client.QueryWorkflowWithOptionsRequest) (*client.QueryWorkflowWithOptionsResponse, error)

QueryWorkflowWithOptions provides a mock function with given fields: ctx, request

func (*Client) RecordActivityHeartbeat 

func (_m *Client) RecordActivityHeartbeat(ctx context.Context, taskToken []byte, details ...interface{}) error

RecordActivityHeartbeat provides a mock function with given fields: ctx, taskToken, details

func (*Client) RecordActivityHeartbeatByID 

func (_m *Client) RecordActivityHeartbeatByID(ctx context.Context, namespace string, workflowID string, runID string, activityID string, details ...interface{}) error

RecordActivityHeartbeatByID provides a mock function with given fields: ctx, namespace, workflowID, runID, activityID, details

func (*Client) ResetWorkflowExecution 

func (_m *Client) ResetWorkflowExecution(ctx context.Context, request *workflowservice.ResetWorkflowExecutionRequest) (*workflowservice.ResetWorkflowExecutionResponse, error)

ResetWorkflowExecution provides a mock function with given fields: ctx, request

func (*Client) ScanWorkflow 

func (_m *Client) ScanWorkflow(ctx context.Context, request *workflowservice.ScanWorkflowExecutionsRequest) (*workflowservice.ScanWorkflowExecutionsResponse, error)

ScanWorkflow provides a mock function with given fields: ctx, request

func (*Client) ScheduleClient 

func (_m *Client) ScheduleClient() client.ScheduleClient

ScheduleClient provides a mock function with no fields

func (*Client) SignalWithStartWorkflow 

func (_m *Client) SignalWithStartWorkflow(ctx context.Context, workflowID string, signalName string, signalArg interface{}, options client.StartWorkflowOptions, workflow interface{}, workflowArgs ...interface{}) (client.WorkflowRun, error)

SignalWithStartWorkflow provides a mock function with given fields: ctx, workflowID, signalName, signalArg, options, workflow, workflowArgs

func (*Client) SignalWorkflow 

func (_m *Client) SignalWorkflow(ctx context.Context, workflowID string, runID string, signalName string, arg interface{}) error

SignalWorkflow provides a mock function with given fields: ctx, workflowID, runID, signalName, arg

func (*Client) TerminateWorkflow 

func (_m *Client) TerminateWorkflow(ctx context.Context, workflowID string, runID string, reason string, details ...interface{}) error

TerminateWorkflow provides a mock function with given fields: ctx, workflowID, runID, reason, details

func (*Client) UpdateWithStartWorkflow 

func (_m *Client) UpdateWithStartWorkflow(ctx context.Context, options client.UpdateWithStartWorkflowOptions) (client.WorkflowUpdateHandle, error)

UpdateWithStartWorkflow provides a mock function with given fields: ctx, options

func (*Client) UpdateWorkerBuildIdCompatibility 

func (_m *Client) UpdateWorkerBuildIdCompatibility(ctx context.Context, options *client.UpdateWorkerBuildIdCompatibilityOptions) error

UpdateWorkerBuildIdCompatibility provides a mock function with given fields: ctx, options

func (*Client) UpdateWorkerVersioningRules 

func (_m *Client) UpdateWorkerVersioningRules(ctx context.Context, options client.UpdateWorkerVersioningRulesOptions) (*client.WorkerVersioningRules, error)

UpdateWorkerVersioningRules provides a mock function with given fields: ctx, options

func (*Client) UpdateWorkflow 

func (_m *Client) UpdateWorkflow(ctx context.Context, options client.UpdateWorkflowOptions) (client.WorkflowUpdateHandle, error)

UpdateWorkflow provides a mock function with given fields: ctx, options

func (*Client) WorkflowService 

func (_m *Client) WorkflowService() workflowservice.WorkflowServiceClient

WorkflowService provides a mock function with no fields

type Client_CancelWorkflow_Call 

type Client_CancelWorkflow_Call struct {
	*mock.Call
}

Client_CancelWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelWorkflow'

func (*Client_CancelWorkflow_Call) Return 

func (_c *Client_CancelWorkflow_Call) Return(_a0 error) *Client_CancelWorkflow_Call

func (*Client_CancelWorkflow_Call) Run 

func (_c *Client_CancelWorkflow_Call) Run(run func(ctx context.Context, workflowID string, runID string)) *Client_CancelWorkflow_Call

func (*Client_CancelWorkflow_Call) RunAndReturn 

func (_c *Client_CancelWorkflow_Call) RunAndReturn(run func(context.Context, string, string) error) *Client_CancelWorkflow_Call

type Client_CheckHealth_Call 

type Client_CheckHealth_Call struct {
	*mock.Call
}

Client_CheckHealth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckHealth'

func (*Client_CheckHealth_Call) Return 

func (_c *Client_CheckHealth_Call) Return(_a0 *client.CheckHealthResponse, _a1 error) *Client_CheckHealth_Call

func (*Client_CheckHealth_Call) Run 

func (_c *Client_CheckHealth_Call) Run(run func(ctx context.Context, request *client.CheckHealthRequest)) *Client_CheckHealth_Call

func (*Client_CheckHealth_Call) RunAndReturn 

func (_c *Client_CheckHealth_Call) RunAndReturn(run func(context.Context, *client.CheckHealthRequest) (*client.CheckHealthResponse, error)) *Client_CheckHealth_Call

type Client_Close_Call 

type Client_Close_Call struct {
	*mock.Call
}

Client_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'

func (*Client_Close_Call) Return 

func (_c *Client_Close_Call) Return() *Client_Close_Call

func (*Client_Close_Call) Run 

func (_c *Client_Close_Call) Run(run func()) *Client_Close_Call

func (*Client_Close_Call) RunAndReturn 

func (_c *Client_Close_Call) RunAndReturn(run func()) *Client_Close_Call

type Client_CompleteActivityByID_Call 

type Client_CompleteActivityByID_Call struct {
	*mock.Call
}

Client_CompleteActivityByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteActivityByID'

func (*Client_CompleteActivityByID_Call) Return 

func (_c *Client_CompleteActivityByID_Call) Return(_a0 error) *Client_CompleteActivityByID_Call

func (*Client_CompleteActivityByID_Call) Run 

func (_c *Client_CompleteActivityByID_Call) Run(run func(ctx context.Context, namespace string, workflowID string, runID string, activityID string, result interface{}, err error)) *Client_CompleteActivityByID_Call

func (*Client_CompleteActivityByID_Call) RunAndReturn 

func (_c *Client_CompleteActivityByID_Call) RunAndReturn(run func(context.Context, string, string, string, string, interface{}, error) error) *Client_CompleteActivityByID_Call

type Client_CompleteActivity_Call 

type Client_CompleteActivity_Call struct {
	*mock.Call
}

Client_CompleteActivity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteActivity'

func (*Client_CompleteActivity_Call) Return 

func (_c *Client_CompleteActivity_Call) Return(_a0 error) *Client_CompleteActivity_Call

func (*Client_CompleteActivity_Call) Run 

func (_c *Client_CompleteActivity_Call) Run(run func(ctx context.Context, taskToken []byte, result interface{}, err error)) *Client_CompleteActivity_Call

func (*Client_CompleteActivity_Call) RunAndReturn 

func (_c *Client_CompleteActivity_Call) RunAndReturn(run func(context.Context, []byte, interface{}, error) error) *Client_CompleteActivity_Call

type Client_CountWorkflow_Call 

type Client_CountWorkflow_Call struct {
	*mock.Call
}

Client_CountWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountWorkflow'

func (*Client_CountWorkflow_Call) Return 

func (_c *Client_CountWorkflow_Call) Return(_a0 *workflowservice.CountWorkflowExecutionsResponse, _a1 error) *Client_CountWorkflow_Call

func (*Client_CountWorkflow_Call) Run 

func (_c *Client_CountWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.CountWorkflowExecutionsRequest)) *Client_CountWorkflow_Call

func (*Client_CountWorkflow_Call) RunAndReturn 

func (_c *Client_CountWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.CountWorkflowExecutionsRequest) (*workflowservice.CountWorkflowExecutionsResponse, error)) *Client_CountWorkflow_Call

type Client_DescribeTaskQueueEnhanced_Call 

type Client_DescribeTaskQueueEnhanced_Call struct {
	*mock.Call
}

Client_DescribeTaskQueueEnhanced_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTaskQueueEnhanced'

func (*Client_DescribeTaskQueueEnhanced_Call) Return 

func (_c *Client_DescribeTaskQueueEnhanced_Call) Return(_a0 client.TaskQueueDescription, _a1 error) *Client_DescribeTaskQueueEnhanced_Call

func (*Client_DescribeTaskQueueEnhanced_Call) Run 

func (_c *Client_DescribeTaskQueueEnhanced_Call) Run(run func(ctx context.Context, options client.DescribeTaskQueueEnhancedOptions)) *Client_DescribeTaskQueueEnhanced_Call

func (*Client_DescribeTaskQueueEnhanced_Call) RunAndReturn 

func (_c *Client_DescribeTaskQueueEnhanced_Call) RunAndReturn(run func(context.Context, client.DescribeTaskQueueEnhancedOptions) (client.TaskQueueDescription, error)) *Client_DescribeTaskQueueEnhanced_Call

type Client_DescribeTaskQueue_Call 

type Client_DescribeTaskQueue_Call struct {
	*mock.Call
}

Client_DescribeTaskQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTaskQueue'

func (*Client_DescribeTaskQueue_Call) Return 

func (_c *Client_DescribeTaskQueue_Call) Return(_a0 *workflowservice.DescribeTaskQueueResponse, _a1 error) *Client_DescribeTaskQueue_Call

func (*Client_DescribeTaskQueue_Call) Run 

func (_c *Client_DescribeTaskQueue_Call) Run(run func(ctx context.Context, taskqueue string, taskqueueType enums.TaskQueueType)) *Client_DescribeTaskQueue_Call

func (*Client_DescribeTaskQueue_Call) RunAndReturn 

func (_c *Client_DescribeTaskQueue_Call) RunAndReturn(run func(context.Context, string, enums.TaskQueueType) (*workflowservice.DescribeTaskQueueResponse, error)) *Client_DescribeTaskQueue_Call

type Client_DescribeWorkflowExecution_Call 

type Client_DescribeWorkflowExecution_Call struct {
	*mock.Call
}

Client_DescribeWorkflowExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeWorkflowExecution'

func (*Client_DescribeWorkflowExecution_Call) Return 

func (_c *Client_DescribeWorkflowExecution_Call) Return(_a0 *workflowservice.DescribeWorkflowExecutionResponse, _a1 error) *Client_DescribeWorkflowExecution_Call

func (*Client_DescribeWorkflowExecution_Call) Run 

func (_c *Client_DescribeWorkflowExecution_Call) Run(run func(ctx context.Context, workflowID string, runID string)) *Client_DescribeWorkflowExecution_Call

func (*Client_DescribeWorkflowExecution_Call) RunAndReturn 

func (_c *Client_DescribeWorkflowExecution_Call) RunAndReturn(run func(context.Context, string, string) (*workflowservice.DescribeWorkflowExecutionResponse, error)) *Client_DescribeWorkflowExecution_Call

type Client_ExecuteWorkflow_Call 

type Client_ExecuteWorkflow_Call struct {
	*mock.Call
}

Client_ExecuteWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExecuteWorkflow'

func (*Client_ExecuteWorkflow_Call) Return 

func (_c *Client_ExecuteWorkflow_Call) Return(_a0 client.WorkflowRun, _a1 error) *Client_ExecuteWorkflow_Call

func (*Client_ExecuteWorkflow_Call) Run 

func (_c *Client_ExecuteWorkflow_Call) Run(run func(ctx context.Context, options client.StartWorkflowOptions, workflow interface{}, args ...interface{})) *Client_ExecuteWorkflow_Call

func (*Client_ExecuteWorkflow_Call) RunAndReturn 

func (_c *Client_ExecuteWorkflow_Call) RunAndReturn(run func(context.Context, client.StartWorkflowOptions, interface{}, ...interface{}) (client.WorkflowRun, error)) *Client_ExecuteWorkflow_Call

type Client_Expecter 

type Client_Expecter struct {
	// contains filtered or unexported fields
}

func (*Client_Expecter) CancelWorkflow 

func (_e *Client_Expecter) CancelWorkflow(ctx interface{}, workflowID interface{}, runID interface{}) *Client_CancelWorkflow_Call

CancelWorkflow is a helper method to define mock.On call

  • ctx context.Context
  • workflowID string
  • runID string

func (*Client_Expecter) CheckHealth 

func (_e *Client_Expecter) CheckHealth(ctx interface{}, request interface{}) *Client_CheckHealth_Call

CheckHealth is a helper method to define mock.On call

  • ctx context.Context
  • request *client.CheckHealthRequest

func (*Client_Expecter) Close 

func (_e *Client_Expecter) Close() *Client_Close_Call

Close is a helper method to define mock.On call

func (*Client_Expecter) CompleteActivity 

func (_e *Client_Expecter) CompleteActivity(ctx interface{}, taskToken interface{}, result interface{}, err interface{}) *Client_CompleteActivity_Call

CompleteActivity is a helper method to define mock.On call

  • ctx context.Context
  • taskToken []byte
  • result interface{}
  • err error

func (*Client_Expecter) CompleteActivityByID 

func (_e *Client_Expecter) CompleteActivityByID(ctx interface{}, namespace interface{}, workflowID interface{}, runID interface{}, activityID interface{}, result interface{}, err interface{}) *Client_CompleteActivityByID_Call

CompleteActivityByID is a helper method to define mock.On call

  • ctx context.Context
  • namespace string
  • workflowID string
  • runID string
  • activityID string
  • result interface{}
  • err error

func (*Client_Expecter) CountWorkflow 

func (_e *Client_Expecter) CountWorkflow(ctx interface{}, request interface{}) *Client_CountWorkflow_Call

CountWorkflow is a helper method to define mock.On call

  • ctx context.Context
  • request *workflowservice.CountWorkflowExecutionsRequest

func (*Client_Expecter) DescribeTaskQueue 

func (_e *Client_Expecter) DescribeTaskQueue(ctx interface{}, taskqueue interface{}, taskqueueType interface{}) *Client_DescribeTaskQueue_Call

DescribeTaskQueue is a helper method to define mock.On call

  • ctx context.Context
  • taskqueue string
  • taskqueueType enums.TaskQueueType

func (*Client_Expecter) DescribeTaskQueueEnhanced 

func (_e *Client_Expecter) DescribeTaskQueueEnhanced(ctx interface{}, options interface{}) *Client_DescribeTaskQueueEnhanced_Call

DescribeTaskQueueEnhanced is a helper method to define mock.On call

  • ctx context.Context
  • options client.DescribeTaskQueueEnhancedOptions

func (*Client_Expecter) DescribeWorkflowExecution 

func (_e *Client_Expecter) DescribeWorkflowExecution(ctx interface{}, workflowID interface{}, runID interface{}) *Client_DescribeWorkflowExecution_Call

DescribeWorkflowExecution is a helper method to define mock.On call

  • ctx context.Context
  • workflowID string
  • runID string

func (*Client_Expecter) ExecuteWorkflow 

func (_e *Client_Expecter) ExecuteWorkflow(ctx interface{}, options interface{}, workflow interface{}, args ...interface{}) *Client_ExecuteWorkflow_Call

ExecuteWorkflow is a helper method to define mock.On call

  • ctx context.Context
  • options client.StartWorkflowOptions
  • workflow interface{}
  • args ...interface{}

func (*Client_Expecter) GetSearchAttributes 

func (_e *Client_Expecter) GetSearchAttributes(ctx interface{}) *Client_GetSearchAttributes_Call

GetSearchAttributes is a helper method to define mock.On call

  • ctx context.Context

func (*Client_Expecter) GetWorkerBuildIdCompatibility 

func (_e *Client_Expecter) GetWorkerBuildIdCompatibility(ctx interface{}, options interface{}) *Client_GetWorkerBuildIdCompatibility_Call

GetWorkerBuildIdCompatibility is a helper method to define mock.On call

  • ctx context.Context
  • options *client.GetWorkerBuildIdCompatibilityOptions

func (*Client_Expecter) GetWorkerTaskReachability 

func (_e *Client_Expecter) GetWorkerTaskReachability(ctx interface{}, options interface{}) *Client_GetWorkerTaskReachability_Call

GetWorkerTaskReachability is a helper method to define mock.On call

  • ctx context.Context
  • options *client.GetWorkerTaskReachabilityOptions

func (*Client_Expecter) GetWorkerVersioningRules 

func (_e *Client_Expecter) GetWorkerVersioningRules(ctx interface{}, options interface{}) *Client_GetWorkerVersioningRules_Call

GetWorkerVersioningRules is a helper method to define mock.On call

  • ctx context.Context
  • options client.GetWorkerVersioningOptions

func (*Client_Expecter) GetWorkflow 

func (_e *Client_Expecter) GetWorkflow(ctx interface{}, workflowID interface{}, runID interface{}) *Client_GetWorkflow_Call

GetWorkflow is a helper method to define mock.On call

  • ctx context.Context
  • workflowID string
  • runID string

func (*Client_Expecter) GetWorkflowHistory 

func (_e *Client_Expecter) GetWorkflowHistory(ctx interface{}, workflowID interface{}, runID interface{}, isLongPoll interface{}, filterType interface{}) *Client_GetWorkflowHistory_Call

GetWorkflowHistory is a helper method to define mock.On call

  • ctx context.Context
  • workflowID string
  • runID string
  • isLongPoll bool
  • filterType enums.HistoryEventFilterType

func (*Client_Expecter) GetWorkflowUpdateHandle 

func (_e *Client_Expecter) GetWorkflowUpdateHandle(ref interface{}) *Client_GetWorkflowUpdateHandle_Call

GetWorkflowUpdateHandle is a helper method to define mock.On call

  • ref client.GetWorkflowUpdateHandleOptions

func (*Client_Expecter) ListArchivedWorkflow 

func (_e *Client_Expecter) ListArchivedWorkflow(ctx interface{}, request interface{}) *Client_ListArchivedWorkflow_Call

ListArchivedWorkflow is a helper method to define mock.On call

  • ctx context.Context
  • request *workflowservice.ListArchivedWorkflowExecutionsRequest

func (*Client_Expecter) ListClosedWorkflow 

func (_e *Client_Expecter) ListClosedWorkflow(ctx interface{}, request interface{}) *Client_ListClosedWorkflow_Call

ListClosedWorkflow is a helper method to define mock.On call

  • ctx context.Context
  • request *workflowservice.ListClosedWorkflowExecutionsRequest

func (*Client_Expecter) ListOpenWorkflow 

func (_e *Client_Expecter) ListOpenWorkflow(ctx interface{}, request interface{}) *Client_ListOpenWorkflow_Call

ListOpenWorkflow is a helper method to define mock.On call

  • ctx context.Context
  • request *workflowservice.ListOpenWorkflowExecutionsRequest

func (*Client_Expecter) ListWorkflow 

func (_e *Client_Expecter) ListWorkflow(ctx interface{}, request interface{}) *Client_ListWorkflow_Call

ListWorkflow is a helper method to define mock.On call

  • ctx context.Context
  • request *workflowservice.ListWorkflowExecutionsRequest

func (*Client_Expecter) NewWithStartWorkflowOperation 

func (_e *Client_Expecter) NewWithStartWorkflowOperation(options interface{}, workflow interface{}, args ...interface{}) *Client_NewWithStartWorkflowOperation_Call

NewWithStartWorkflowOperation is a helper method to define mock.On call

  • options client.StartWorkflowOptions
  • workflow interface{}
  • args ...interface{}

func (*Client_Expecter) OperatorService 

func (_e *Client_Expecter) OperatorService() *Client_OperatorService_Call

OperatorService is a helper method to define mock.On call

func (*Client_Expecter) QueryWorkflow 

func (_e *Client_Expecter) QueryWorkflow(ctx interface{}, workflowID interface{}, runID interface{}, queryType interface{}, args ...interface{}) *Client_QueryWorkflow_Call

QueryWorkflow is a helper method to define mock.On call

  • ctx context.Context
  • workflowID string
  • runID string
  • queryType string
  • args ...interface{}

func (*Client_Expecter) QueryWorkflowWithOptions 

func (_e *Client_Expecter) QueryWorkflowWithOptions(ctx interface{}, request interface{}) *Client_QueryWorkflowWithOptions_Call

QueryWorkflowWithOptions is a helper method to define mock.On call

  • ctx context.Context
  • request *client.QueryWorkflowWithOptionsRequest

func (*Client_Expecter) RecordActivityHeartbeat 

func (_e *Client_Expecter) RecordActivityHeartbeat(ctx interface{}, taskToken interface{}, details ...interface{}) *Client_RecordActivityHeartbeat_Call

RecordActivityHeartbeat is a helper method to define mock.On call

  • ctx context.Context
  • taskToken []byte
  • details ...interface{}

func (*Client_Expecter) RecordActivityHeartbeatByID 

func (_e *Client_Expecter) RecordActivityHeartbeatByID(ctx interface{}, namespace interface{}, workflowID interface{}, runID interface{}, activityID interface{}, details ...interface{}) *Client_RecordActivityHeartbeatByID_Call

RecordActivityHeartbeatByID is a helper method to define mock.On call

  • ctx context.Context
  • namespace string
  • workflowID string
  • runID string
  • activityID string
  • details ...interface{}

func (*Client_Expecter) ResetWorkflowExecution 

func (_e *Client_Expecter) ResetWorkflowExecution(ctx interface{}, request interface{}) *Client_ResetWorkflowExecution_Call

ResetWorkflowExecution is a helper method to define mock.On call

  • ctx context.Context
  • request *workflowservice.ResetWorkflowExecutionRequest

func (*Client_Expecter) ScanWorkflow 

func (_e *Client_Expecter) ScanWorkflow(ctx interface{}, request interface{}) *Client_ScanWorkflow_Call

ScanWorkflow is a helper method to define mock.On call

  • ctx context.Context
  • request *workflowservice.ScanWorkflowExecutionsRequest

func (*Client_Expecter) ScheduleClient 

func (_e *Client_Expecter) ScheduleClient() *Client_ScheduleClient_Call

ScheduleClient is a helper method to define mock.On call

func (*Client_Expecter) SignalWithStartWorkflow 

func (_e *Client_Expecter) SignalWithStartWorkflow(ctx interface{}, workflowID interface{}, signalName interface{}, signalArg interface{}, options interface{}, workflow interface{}, workflowArgs ...interface{}) *Client_SignalWithStartWorkflow_Call

SignalWithStartWorkflow is a helper method to define mock.On call

  • ctx context.Context
  • workflowID string
  • signalName string
  • signalArg interface{}
  • options client.StartWorkflowOptions
  • workflow interface{}
  • workflowArgs ...interface{}

func (*Client_Expecter) SignalWorkflow 

func (_e *Client_Expecter) SignalWorkflow(ctx interface{}, workflowID interface{}, runID interface{}, signalName interface{}, arg interface{}) *Client_SignalWorkflow_Call

SignalWorkflow is a helper method to define mock.On call

  • ctx context.Context
  • workflowID string
  • runID string
  • signalName string
  • arg interface{}

func (*Client_Expecter) TerminateWorkflow 

func (_e *Client_Expecter) TerminateWorkflow(ctx interface{}, workflowID interface{}, runID interface{}, reason interface{}, details ...interface{}) *Client_TerminateWorkflow_Call

TerminateWorkflow is a helper method to define mock.On call

  • ctx context.Context
  • workflowID string
  • runID string
  • reason string
  • details ...interface{}

func (*Client_Expecter) UpdateWithStartWorkflow 

func (_e *Client_Expecter) UpdateWithStartWorkflow(ctx interface{}, options interface{}) *Client_UpdateWithStartWorkflow_Call

UpdateWithStartWorkflow is a helper method to define mock.On call

  • ctx context.Context
  • options client.UpdateWithStartWorkflowOptions

func (*Client_Expecter) UpdateWorkerBuildIdCompatibility 

func (_e *Client_Expecter) UpdateWorkerBuildIdCompatibility(ctx interface{}, options interface{}) *Client_UpdateWorkerBuildIdCompatibility_Call

UpdateWorkerBuildIdCompatibility is a helper method to define mock.On call

  • ctx context.Context
  • options *client.UpdateWorkerBuildIdCompatibilityOptions

func (*Client_Expecter) UpdateWorkerVersioningRules 

func (_e *Client_Expecter) UpdateWorkerVersioningRules(ctx interface{}, options interface{}) *Client_UpdateWorkerVersioningRules_Call

UpdateWorkerVersioningRules is a helper method to define mock.On call

  • ctx context.Context
  • options client.UpdateWorkerVersioningRulesOptions

func (*Client_Expecter) UpdateWorkflow 

func (_e *Client_Expecter) UpdateWorkflow(ctx interface{}, options interface{}) *Client_UpdateWorkflow_Call

UpdateWorkflow is a helper method to define mock.On call

  • ctx context.Context
  • options client.UpdateWorkflowOptions

func (*Client_Expecter) WorkflowService 

func (_e *Client_Expecter) WorkflowService() *Client_WorkflowService_Call

WorkflowService is a helper method to define mock.On call

type Client_GetSearchAttributes_Call 

type Client_GetSearchAttributes_Call struct {
	*mock.Call
}

Client_GetSearchAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSearchAttributes'

func (*Client_GetSearchAttributes_Call) Return 

func (_c *Client_GetSearchAttributes_Call) Return(_a0 *workflowservice.GetSearchAttributesResponse, _a1 error) *Client_GetSearchAttributes_Call

func (*Client_GetSearchAttributes_Call) Run 

func (_c *Client_GetSearchAttributes_Call) Run(run func(ctx context.Context)) *Client_GetSearchAttributes_Call

func (*Client_GetSearchAttributes_Call) RunAndReturn 

func (_c *Client_GetSearchAttributes_Call) RunAndReturn(run func(context.Context) (*workflowservice.GetSearchAttributesResponse, error)) *Client_GetSearchAttributes_Call

type Client_GetWorkerBuildIdCompatibility_Call 

type Client_GetWorkerBuildIdCompatibility_Call struct {
	*mock.Call
}

Client_GetWorkerBuildIdCompatibility_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkerBuildIdCompatibility'

func (*Client_GetWorkerBuildIdCompatibility_Call) Return 

func (_c *Client_GetWorkerBuildIdCompatibility_Call) Return(_a0 *client.WorkerBuildIDVersionSets, _a1 error) *Client_GetWorkerBuildIdCompatibility_Call

func (*Client_GetWorkerBuildIdCompatibility_Call) Run 

func (_c *Client_GetWorkerBuildIdCompatibility_Call) Run(run func(ctx context.Context, options *client.GetWorkerBuildIdCompatibilityOptions)) *Client_GetWorkerBuildIdCompatibility_Call

func (*Client_GetWorkerBuildIdCompatibility_Call) RunAndReturn 

func (_c *Client_GetWorkerBuildIdCompatibility_Call) RunAndReturn(run func(context.Context, *client.GetWorkerBuildIdCompatibilityOptions) (*client.WorkerBuildIDVersionSets, error)) *Client_GetWorkerBuildIdCompatibility_Call

type Client_GetWorkerTaskReachability_Call 

type Client_GetWorkerTaskReachability_Call struct {
	*mock.Call
}

Client_GetWorkerTaskReachability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkerTaskReachability'

func (*Client_GetWorkerTaskReachability_Call) Return 

func (_c *Client_GetWorkerTaskReachability_Call) Return(_a0 *client.WorkerTaskReachability, _a1 error) *Client_GetWorkerTaskReachability_Call

func (*Client_GetWorkerTaskReachability_Call) Run 

func (_c *Client_GetWorkerTaskReachability_Call) Run(run func(ctx context.Context, options *client.GetWorkerTaskReachabilityOptions)) *Client_GetWorkerTaskReachability_Call

func (*Client_GetWorkerTaskReachability_Call) RunAndReturn 

func (_c *Client_GetWorkerTaskReachability_Call) RunAndReturn(run func(context.Context, *client.GetWorkerTaskReachabilityOptions) (*client.WorkerTaskReachability, error)) *Client_GetWorkerTaskReachability_Call

type Client_GetWorkerVersioningRules_Call 

type Client_GetWorkerVersioningRules_Call struct {
	*mock.Call
}

Client_GetWorkerVersioningRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkerVersioningRules'

func (*Client_GetWorkerVersioningRules_Call) Return 

func (_c *Client_GetWorkerVersioningRules_Call) Return(_a0 *client.WorkerVersioningRules, _a1 error) *Client_GetWorkerVersioningRules_Call

func (*Client_GetWorkerVersioningRules_Call) Run 

func (_c *Client_GetWorkerVersioningRules_Call) Run(run func(ctx context.Context, options client.GetWorkerVersioningOptions)) *Client_GetWorkerVersioningRules_Call

func (*Client_GetWorkerVersioningRules_Call) RunAndReturn 

func (_c *Client_GetWorkerVersioningRules_Call) RunAndReturn(run func(context.Context, client.GetWorkerVersioningOptions) (*client.WorkerVersioningRules, error)) *Client_GetWorkerVersioningRules_Call

type Client_GetWorkflowHistory_Call 

type Client_GetWorkflowHistory_Call struct {
	*mock.Call
}

Client_GetWorkflowHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkflowHistory'

func (*Client_GetWorkflowHistory_Call) Return 

func (_c *Client_GetWorkflowHistory_Call) Return(_a0 client.HistoryEventIterator) *Client_GetWorkflowHistory_Call

func (*Client_GetWorkflowHistory_Call) Run 

func (_c *Client_GetWorkflowHistory_Call) Run(run func(ctx context.Context, workflowID string, runID string, isLongPoll bool, filterType enums.HistoryEventFilterType)) *Client_GetWorkflowHistory_Call

func (*Client_GetWorkflowHistory_Call) RunAndReturn 

func (_c *Client_GetWorkflowHistory_Call) RunAndReturn(run func(context.Context, string, string, bool, enums.HistoryEventFilterType) client.HistoryEventIterator) *Client_GetWorkflowHistory_Call

type Client_GetWorkflowUpdateHandle_Call 

type Client_GetWorkflowUpdateHandle_Call struct {
	*mock.Call
}

Client_GetWorkflowUpdateHandle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkflowUpdateHandle'

func (*Client_GetWorkflowUpdateHandle_Call) Return 

func (_c *Client_GetWorkflowUpdateHandle_Call) Return(_a0 client.WorkflowUpdateHandle) *Client_GetWorkflowUpdateHandle_Call

func (*Client_GetWorkflowUpdateHandle_Call) Run 

func (_c *Client_GetWorkflowUpdateHandle_Call) Run(run func(ref client.GetWorkflowUpdateHandleOptions)) *Client_GetWorkflowUpdateHandle_Call

func (*Client_GetWorkflowUpdateHandle_Call) RunAndReturn 

func (_c *Client_GetWorkflowUpdateHandle_Call) RunAndReturn(run func(client.GetWorkflowUpdateHandleOptions) client.WorkflowUpdateHandle) *Client_GetWorkflowUpdateHandle_Call

type Client_GetWorkflow_Call 

type Client_GetWorkflow_Call struct {
	*mock.Call
}

Client_GetWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkflow'

func (*Client_GetWorkflow_Call) Return 

func (_c *Client_GetWorkflow_Call) Return(_a0 client.WorkflowRun) *Client_GetWorkflow_Call

func (*Client_GetWorkflow_Call) Run 

func (_c *Client_GetWorkflow_Call) Run(run func(ctx context.Context, workflowID string, runID string)) *Client_GetWorkflow_Call

func (*Client_GetWorkflow_Call) RunAndReturn 

func (_c *Client_GetWorkflow_Call) RunAndReturn(run func(context.Context, string, string) client.WorkflowRun) *Client_GetWorkflow_Call

type Client_ListArchivedWorkflow_Call 

type Client_ListArchivedWorkflow_Call struct {
	*mock.Call
}

Client_ListArchivedWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListArchivedWorkflow'

func (*Client_ListArchivedWorkflow_Call) Return 

func (_c *Client_ListArchivedWorkflow_Call) Return(_a0 *workflowservice.ListArchivedWorkflowExecutionsResponse, _a1 error) *Client_ListArchivedWorkflow_Call

func (*Client_ListArchivedWorkflow_Call) Run 

func (_c *Client_ListArchivedWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.ListArchivedWorkflowExecutionsRequest)) *Client_ListArchivedWorkflow_Call

func (*Client_ListArchivedWorkflow_Call) RunAndReturn 

func (_c *Client_ListArchivedWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.ListArchivedWorkflowExecutionsRequest) (*workflowservice.ListArchivedWorkflowExecutionsResponse, error)) *Client_ListArchivedWorkflow_Call

type Client_ListClosedWorkflow_Call 

type Client_ListClosedWorkflow_Call struct {
	*mock.Call
}

Client_ListClosedWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClosedWorkflow'

func (*Client_ListClosedWorkflow_Call) Return 

func (_c *Client_ListClosedWorkflow_Call) Return(_a0 *workflowservice.ListClosedWorkflowExecutionsResponse, _a1 error) *Client_ListClosedWorkflow_Call

func (*Client_ListClosedWorkflow_Call) Run 

func (_c *Client_ListClosedWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.ListClosedWorkflowExecutionsRequest)) *Client_ListClosedWorkflow_Call

func (*Client_ListClosedWorkflow_Call) RunAndReturn 

func (_c *Client_ListClosedWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.ListClosedWorkflowExecutionsRequest) (*workflowservice.ListClosedWorkflowExecutionsResponse, error)) *Client_ListClosedWorkflow_Call

type Client_ListOpenWorkflow_Call 

type Client_ListOpenWorkflow_Call struct {
	*mock.Call
}

Client_ListOpenWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOpenWorkflow'

func (*Client_ListOpenWorkflow_Call) Return 

func (_c *Client_ListOpenWorkflow_Call) Return(_a0 *workflowservice.ListOpenWorkflowExecutionsResponse, _a1 error) *Client_ListOpenWorkflow_Call

func (*Client_ListOpenWorkflow_Call) Run 

func (_c *Client_ListOpenWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.ListOpenWorkflowExecutionsRequest)) *Client_ListOpenWorkflow_Call

func (*Client_ListOpenWorkflow_Call) RunAndReturn 

func (_c *Client_ListOpenWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.ListOpenWorkflowExecutionsRequest) (*workflowservice.ListOpenWorkflowExecutionsResponse, error)) *Client_ListOpenWorkflow_Call

type Client_ListWorkflow_Call 

type Client_ListWorkflow_Call struct {
	*mock.Call
}

Client_ListWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListWorkflow'

func (*Client_ListWorkflow_Call) Return 

func (_c *Client_ListWorkflow_Call) Return(_a0 *workflowservice.ListWorkflowExecutionsResponse, _a1 error) *Client_ListWorkflow_Call

func (*Client_ListWorkflow_Call) Run 

func (_c *Client_ListWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.ListWorkflowExecutionsRequest)) *Client_ListWorkflow_Call

func (*Client_ListWorkflow_Call) RunAndReturn 

func (_c *Client_ListWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.ListWorkflowExecutionsRequest) (*workflowservice.ListWorkflowExecutionsResponse, error)) *Client_ListWorkflow_Call

type Client_NewWithStartWorkflowOperation_Call 

type Client_NewWithStartWorkflowOperation_Call struct {
	*mock.Call
}

Client_NewWithStartWorkflowOperation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewWithStartWorkflowOperation'

func (*Client_NewWithStartWorkflowOperation_Call) Return 

func (_c *Client_NewWithStartWorkflowOperation_Call) Return(_a0 client.WithStartWorkflowOperation) *Client_NewWithStartWorkflowOperation_Call

func (*Client_NewWithStartWorkflowOperation_Call) Run 

func (_c *Client_NewWithStartWorkflowOperation_Call) Run(run func(options client.StartWorkflowOptions, workflow interface{}, args ...interface{})) *Client_NewWithStartWorkflowOperation_Call

func (*Client_NewWithStartWorkflowOperation_Call) RunAndReturn 

func (_c *Client_NewWithStartWorkflowOperation_Call) RunAndReturn(run func(client.StartWorkflowOptions, interface{}, ...interface{}) client.WithStartWorkflowOperation) *Client_NewWithStartWorkflowOperation_Call

type Client_OperatorService_Call 

type Client_OperatorService_Call struct {
	*mock.Call
}

Client_OperatorService_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OperatorService'

func (*Client_OperatorService_Call) Return 

func (_c *Client_OperatorService_Call) Return(_a0 operatorservice.OperatorServiceClient) *Client_OperatorService_Call

func (*Client_OperatorService_Call) Run 

func (_c *Client_OperatorService_Call) Run(run func()) *Client_OperatorService_Call

func (*Client_OperatorService_Call) RunAndReturn 

func (_c *Client_OperatorService_Call) RunAndReturn(run func() operatorservice.OperatorServiceClient) *Client_OperatorService_Call

type Client_QueryWorkflowWithOptions_Call 

type Client_QueryWorkflowWithOptions_Call struct {
	*mock.Call
}

Client_QueryWorkflowWithOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryWorkflowWithOptions'

func (*Client_QueryWorkflowWithOptions_Call) Return 

func (_c *Client_QueryWorkflowWithOptions_Call) Return(_a0 *client.QueryWorkflowWithOptionsResponse, _a1 error) *Client_QueryWorkflowWithOptions_Call

func (*Client_QueryWorkflowWithOptions_Call) Run 

func (_c *Client_QueryWorkflowWithOptions_Call) Run(run func(ctx context.Context, request *client.QueryWorkflowWithOptionsRequest)) *Client_QueryWorkflowWithOptions_Call

func (*Client_QueryWorkflowWithOptions_Call) RunAndReturn 

func (_c *Client_QueryWorkflowWithOptions_Call) RunAndReturn(run func(context.Context, *client.QueryWorkflowWithOptionsRequest) (*client.QueryWorkflowWithOptionsResponse, error)) *Client_QueryWorkflowWithOptions_Call

type Client_QueryWorkflow_Call 

type Client_QueryWorkflow_Call struct {
	*mock.Call
}

Client_QueryWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryWorkflow'

func (*Client_QueryWorkflow_Call) Return 

func (_c *Client_QueryWorkflow_Call) Return(_a0 converter.EncodedValue, _a1 error) *Client_QueryWorkflow_Call

func (*Client_QueryWorkflow_Call) Run 

func (_c *Client_QueryWorkflow_Call) Run(run func(ctx context.Context, workflowID string, runID string, queryType string, args ...interface{})) *Client_QueryWorkflow_Call

func (*Client_QueryWorkflow_Call) RunAndReturn 

func (_c *Client_QueryWorkflow_Call) RunAndReturn(run func(context.Context, string, string, string, ...interface{}) (converter.EncodedValue, error)) *Client_QueryWorkflow_Call

type Client_RecordActivityHeartbeatByID_Call 

type Client_RecordActivityHeartbeatByID_Call struct {
	*mock.Call
}

Client_RecordActivityHeartbeatByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordActivityHeartbeatByID'

func (*Client_RecordActivityHeartbeatByID_Call) Return 

func (_c *Client_RecordActivityHeartbeatByID_Call) Return(_a0 error) *Client_RecordActivityHeartbeatByID_Call

func (*Client_RecordActivityHeartbeatByID_Call) Run 

func (_c *Client_RecordActivityHeartbeatByID_Call) Run(run func(ctx context.Context, namespace string, workflowID string, runID string, activityID string, details ...interface{})) *Client_RecordActivityHeartbeatByID_Call

func (*Client_RecordActivityHeartbeatByID_Call) RunAndReturn 

func (_c *Client_RecordActivityHeartbeatByID_Call) RunAndReturn(run func(context.Context, string, string, string, string, ...interface{}) error) *Client_RecordActivityHeartbeatByID_Call

type Client_RecordActivityHeartbeat_Call 

type Client_RecordActivityHeartbeat_Call struct {
	*mock.Call
}

Client_RecordActivityHeartbeat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordActivityHeartbeat'

func (*Client_RecordActivityHeartbeat_Call) Return 

func (_c *Client_RecordActivityHeartbeat_Call) Return(_a0 error) *Client_RecordActivityHeartbeat_Call

func (*Client_RecordActivityHeartbeat_Call) Run 

func (_c *Client_RecordActivityHeartbeat_Call) Run(run func(ctx context.Context, taskToken []byte, details ...interface{})) *Client_RecordActivityHeartbeat_Call

func (*Client_RecordActivityHeartbeat_Call) RunAndReturn 

func (_c *Client_RecordActivityHeartbeat_Call) RunAndReturn(run func(context.Context, []byte, ...interface{}) error) *Client_RecordActivityHeartbeat_Call

type Client_ResetWorkflowExecution_Call 

type Client_ResetWorkflowExecution_Call struct {
	*mock.Call
}

Client_ResetWorkflowExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetWorkflowExecution'

func (*Client_ResetWorkflowExecution_Call) Return 

func (_c *Client_ResetWorkflowExecution_Call) Return(_a0 *workflowservice.ResetWorkflowExecutionResponse, _a1 error) *Client_ResetWorkflowExecution_Call

func (*Client_ResetWorkflowExecution_Call) Run 

func (_c *Client_ResetWorkflowExecution_Call) Run(run func(ctx context.Context, request *workflowservice.ResetWorkflowExecutionRequest)) *Client_ResetWorkflowExecution_Call

func (*Client_ResetWorkflowExecution_Call) RunAndReturn 

func (_c *Client_ResetWorkflowExecution_Call) RunAndReturn(run func(context.Context, *workflowservice.ResetWorkflowExecutionRequest) (*workflowservice.ResetWorkflowExecutionResponse, error)) *Client_ResetWorkflowExecution_Call

type Client_ScanWorkflow_Call 

type Client_ScanWorkflow_Call struct {
	*mock.Call
}

Client_ScanWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScanWorkflow'

func (*Client_ScanWorkflow_Call) Return 

func (_c *Client_ScanWorkflow_Call) Return(_a0 *workflowservice.ScanWorkflowExecutionsResponse, _a1 error) *Client_ScanWorkflow_Call

func (*Client_ScanWorkflow_Call) Run 

func (_c *Client_ScanWorkflow_Call) Run(run func(ctx context.Context, request *workflowservice.ScanWorkflowExecutionsRequest)) *Client_ScanWorkflow_Call

func (*Client_ScanWorkflow_Call) RunAndReturn 

func (_c *Client_ScanWorkflow_Call) RunAndReturn(run func(context.Context, *workflowservice.ScanWorkflowExecutionsRequest) (*workflowservice.ScanWorkflowExecutionsResponse, error)) *Client_ScanWorkflow_Call

type Client_ScheduleClient_Call 

type Client_ScheduleClient_Call struct {
	*mock.Call
}

Client_ScheduleClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScheduleClient'

func (*Client_ScheduleClient_Call) Return 

func (_c *Client_ScheduleClient_Call) Return(_a0 client.ScheduleClient) *Client_ScheduleClient_Call

func (*Client_ScheduleClient_Call) Run 

func (_c *Client_ScheduleClient_Call) Run(run func()) *Client_ScheduleClient_Call

func (*Client_ScheduleClient_Call) RunAndReturn 

func (_c *Client_ScheduleClient_Call) RunAndReturn(run func() client.ScheduleClient) *Client_ScheduleClient_Call

type Client_SignalWithStartWorkflow_Call 

type Client_SignalWithStartWorkflow_Call struct {
	*mock.Call
}

Client_SignalWithStartWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignalWithStartWorkflow'

func (*Client_SignalWithStartWorkflow_Call) Return 

func (_c *Client_SignalWithStartWorkflow_Call) Return(_a0 client.WorkflowRun, _a1 error) *Client_SignalWithStartWorkflow_Call

func (*Client_SignalWithStartWorkflow_Call) Run 

func (_c *Client_SignalWithStartWorkflow_Call) Run(run func(ctx context.Context, workflowID string, signalName string, signalArg interface{}, options client.StartWorkflowOptions, workflow interface{}, workflowArgs ...interface{})) *Client_SignalWithStartWorkflow_Call

func (*Client_SignalWithStartWorkflow_Call) RunAndReturn 

func (_c *Client_SignalWithStartWorkflow_Call) RunAndReturn(run func(context.Context, string, string, interface{}, client.StartWorkflowOptions, interface{}, ...interface{}) (client.WorkflowRun, error)) *Client_SignalWithStartWorkflow_Call

type Client_SignalWorkflow_Call 

type Client_SignalWorkflow_Call struct {
	*mock.Call
}

Client_SignalWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignalWorkflow'

func (*Client_SignalWorkflow_Call) Return 

func (_c *Client_SignalWorkflow_Call) Return(_a0 error) *Client_SignalWorkflow_Call

func (*Client_SignalWorkflow_Call) Run 

func (_c *Client_SignalWorkflow_Call) Run(run func(ctx context.Context, workflowID string, runID string, signalName string, arg interface{})) *Client_SignalWorkflow_Call

func (*Client_SignalWorkflow_Call) RunAndReturn 

func (_c *Client_SignalWorkflow_Call) RunAndReturn(run func(context.Context, string, string, string, interface{}) error) *Client_SignalWorkflow_Call

type Client_TerminateWorkflow_Call 

type Client_TerminateWorkflow_Call struct {
	*mock.Call
}

Client_TerminateWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TerminateWorkflow'

func (*Client_TerminateWorkflow_Call) Return 

func (_c *Client_TerminateWorkflow_Call) Return(_a0 error) *Client_TerminateWorkflow_Call

func (*Client_TerminateWorkflow_Call) Run 

func (_c *Client_TerminateWorkflow_Call) Run(run func(ctx context.Context, workflowID string, runID string, reason string, details ...interface{})) *Client_TerminateWorkflow_Call

func (*Client_TerminateWorkflow_Call) RunAndReturn 

func (_c *Client_TerminateWorkflow_Call) RunAndReturn(run func(context.Context, string, string, string, ...interface{}) error) *Client_TerminateWorkflow_Call

type Client_UpdateWithStartWorkflow_Call 

type Client_UpdateWithStartWorkflow_Call struct {
	*mock.Call
}

Client_UpdateWithStartWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWithStartWorkflow'

func (*Client_UpdateWithStartWorkflow_Call) Return 

func (_c *Client_UpdateWithStartWorkflow_Call) Return(_a0 client.WorkflowUpdateHandle, _a1 error) *Client_UpdateWithStartWorkflow_Call

func (*Client_UpdateWithStartWorkflow_Call) Run 

func (_c *Client_UpdateWithStartWorkflow_Call) Run(run func(ctx context.Context, options client.UpdateWithStartWorkflowOptions)) *Client_UpdateWithStartWorkflow_Call

func (*Client_UpdateWithStartWorkflow_Call) RunAndReturn 

func (_c *Client_UpdateWithStartWorkflow_Call) RunAndReturn(run func(context.Context, client.UpdateWithStartWorkflowOptions) (client.WorkflowUpdateHandle, error)) *Client_UpdateWithStartWorkflow_Call

type Client_UpdateWorkerBuildIdCompatibility_Call 

type Client_UpdateWorkerBuildIdCompatibility_Call struct {
	*mock.Call
}

Client_UpdateWorkerBuildIdCompatibility_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWorkerBuildIdCompatibility'

func (*Client_UpdateWorkerBuildIdCompatibility_Call) Return 

func (_c *Client_UpdateWorkerBuildIdCompatibility_Call) Return(_a0 error) *Client_UpdateWorkerBuildIdCompatibility_Call

func (*Client_UpdateWorkerBuildIdCompatibility_Call) Run 

func (_c *Client_UpdateWorkerBuildIdCompatibility_Call) Run(run func(ctx context.Context, options *client.UpdateWorkerBuildIdCompatibilityOptions)) *Client_UpdateWorkerBuildIdCompatibility_Call

func (*Client_UpdateWorkerBuildIdCompatibility_Call) RunAndReturn 

func (_c *Client_UpdateWorkerBuildIdCompatibility_Call) RunAndReturn(run func(context.Context, *client.UpdateWorkerBuildIdCompatibilityOptions) error) *Client_UpdateWorkerBuildIdCompatibility_Call

type Client_UpdateWorkerVersioningRules_Call 

type Client_UpdateWorkerVersioningRules_Call struct {
	*mock.Call
}

Client_UpdateWorkerVersioningRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWorkerVersioningRules'

func (*Client_UpdateWorkerVersioningRules_Call) Return 

func (_c *Client_UpdateWorkerVersioningRules_Call) Return(_a0 *client.WorkerVersioningRules, _a1 error) *Client_UpdateWorkerVersioningRules_Call

func (*Client_UpdateWorkerVersioningRules_Call) Run 

func (_c *Client_UpdateWorkerVersioningRules_Call) Run(run func(ctx context.Context, options client.UpdateWorkerVersioningRulesOptions)) *Client_UpdateWorkerVersioningRules_Call

func (*Client_UpdateWorkerVersioningRules_Call) RunAndReturn 

func (_c *Client_UpdateWorkerVersioningRules_Call) RunAndReturn(run func(context.Context, client.UpdateWorkerVersioningRulesOptions) (*client.WorkerVersioningRules, error)) *Client_UpdateWorkerVersioningRules_Call

type Client_UpdateWorkflow_Call 

type Client_UpdateWorkflow_Call struct {
	*mock.Call
}

Client_UpdateWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWorkflow'

func (*Client_UpdateWorkflow_Call) Return 

func (_c *Client_UpdateWorkflow_Call) Return(_a0 client.WorkflowUpdateHandle, _a1 error) *Client_UpdateWorkflow_Call

func (*Client_UpdateWorkflow_Call) Run 

func (_c *Client_UpdateWorkflow_Call) Run(run func(ctx context.Context, options client.UpdateWorkflowOptions)) *Client_UpdateWorkflow_Call

func (*Client_UpdateWorkflow_Call) RunAndReturn 

func (_c *Client_UpdateWorkflow_Call) RunAndReturn(run func(context.Context, client.UpdateWorkflowOptions) (client.WorkflowUpdateHandle, error)) *Client_UpdateWorkflow_Call

type Client_WorkflowService_Call 

type Client_WorkflowService_Call struct {
	*mock.Call
}

Client_WorkflowService_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WorkflowService'

func (*Client_WorkflowService_Call) Return 

func (_c *Client_WorkflowService_Call) Return(_a0 workflowservice.WorkflowServiceClient) *Client_WorkflowService_Call

func (*Client_WorkflowService_Call) Run 

func (_c *Client_WorkflowService_Call) Run(run func()) *Client_WorkflowService_Call

func (*Client_WorkflowService_Call) RunAndReturn 

func (_c *Client_WorkflowService_Call) RunAndReturn(run func() workflowservice.WorkflowServiceClient) *Client_WorkflowService_Call

type Hook 

type Hook struct {
	mock.Mock
}

Hook is an autogenerated mock type for the Hook type

func NewHook 

func NewHook(t interface {
	mock.TestingT
	Cleanup(func())
},
) *Hook

NewHook creates a new instance of Hook. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*Hook) EXPECT 

func (_m *Hook) EXPECT() *Hook_Expecter

func (*Hook) OnAssistantChunk 

func (_m *Hook) OnAssistantChunk(_a0 context.Context, _a1 messages.Message[messages.AssistantMessage])

OnAssistantChunk provides a mock function with given fields: _a0, _a1

func (*Hook) OnAssistantMessage 

func (_m *Hook) OnAssistantMessage(_a0 context.Context, _a1 messages.Message[messages.AssistantMessage])

OnAssistantMessage provides a mock function with given fields: _a0, _a1

func (*Hook) OnError 

func (_m *Hook) OnError(_a0 context.Context, _a1 error)

OnError provides a mock function with given fields: _a0, _a1

func (*Hook) OnToolCallChunk 

func (_m *Hook) OnToolCallChunk(_a0 context.Context, _a1 messages.Message[messages.ToolCallMessage])

OnToolCallChunk provides a mock function with given fields: _a0, _a1

func (*Hook) OnToolCallMessage 

func (_m *Hook) OnToolCallMessage(_a0 context.Context, _a1 messages.Message[messages.ToolCallMessage])

OnToolCallMessage provides a mock function with given fields: _a0, _a1

func (*Hook) OnToolCallResponse 

func (_m *Hook) OnToolCallResponse(_a0 context.Context, _a1 messages.Message[messages.ToolResponse])

OnToolCallResponse provides a mock function with given fields: _a0, _a1

func (*Hook) OnUserPrompt 

func (_m *Hook) OnUserPrompt(_a0 context.Context, _a1 messages.Message[messages.UserMessage])

OnUserPrompt provides a mock function with given fields: _a0, _a1

type Hook_Expecter 

type Hook_Expecter struct {
	// contains filtered or unexported fields
}

func (*Hook_Expecter) OnAssistantChunk 

func (_e *Hook_Expecter) OnAssistantChunk(_a0 interface{}, _a1 interface{}) *Hook_OnAssistantChunk_Call

OnAssistantChunk is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 messages.Message[messages.AssistantMessage]

func (*Hook_Expecter) OnAssistantMessage 

func (_e *Hook_Expecter) OnAssistantMessage(_a0 interface{}, _a1 interface{}) *Hook_OnAssistantMessage_Call

OnAssistantMessage is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 messages.Message[messages.AssistantMessage]

func (*Hook_Expecter) OnError 

func (_e *Hook_Expecter) OnError(_a0 interface{}, _a1 interface{}) *Hook_OnError_Call

OnError is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 error

func (*Hook_Expecter) OnToolCallChunk 

func (_e *Hook_Expecter) OnToolCallChunk(_a0 interface{}, _a1 interface{}) *Hook_OnToolCallChunk_Call

OnToolCallChunk is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 messages.Message[messages.ToolCallMessage]

func (*Hook_Expecter) OnToolCallMessage 

func (_e *Hook_Expecter) OnToolCallMessage(_a0 interface{}, _a1 interface{}) *Hook_OnToolCallMessage_Call

OnToolCallMessage is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 messages.Message[messages.ToolCallMessage]

func (*Hook_Expecter) OnToolCallResponse 

func (_e *Hook_Expecter) OnToolCallResponse(_a0 interface{}, _a1 interface{}) *Hook_OnToolCallResponse_Call

OnToolCallResponse is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 messages.Message[messages.ToolResponse]

func (*Hook_Expecter) OnUserPrompt 

func (_e *Hook_Expecter) OnUserPrompt(_a0 interface{}, _a1 interface{}) *Hook_OnUserPrompt_Call

OnUserPrompt is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 messages.Message[messages.UserMessage]

type Hook_OnAssistantChunk_Call 

type Hook_OnAssistantChunk_Call struct {
	*mock.Call
}

Hook_OnAssistantChunk_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnAssistantChunk'

func (*Hook_OnAssistantChunk_Call) Return 

func (_c *Hook_OnAssistantChunk_Call) Return() *Hook_OnAssistantChunk_Call

func (*Hook_OnAssistantChunk_Call) Run 

func (_c *Hook_OnAssistantChunk_Call) Run(run func(_a0 context.Context, _a1 messages.Message[messages.AssistantMessage])) *Hook_OnAssistantChunk_Call

func (*Hook_OnAssistantChunk_Call) RunAndReturn 

func (_c *Hook_OnAssistantChunk_Call) RunAndReturn(run func(context.Context, messages.Message[messages.AssistantMessage])) *Hook_OnAssistantChunk_Call

type Hook_OnAssistantMessage_Call 

type Hook_OnAssistantMessage_Call struct {
	*mock.Call
}

Hook_OnAssistantMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnAssistantMessage'

func (*Hook_OnAssistantMessage_Call) Return 

func (_c *Hook_OnAssistantMessage_Call) Return() *Hook_OnAssistantMessage_Call

func (*Hook_OnAssistantMessage_Call) Run 

func (_c *Hook_OnAssistantMessage_Call) Run(run func(_a0 context.Context, _a1 messages.Message[messages.AssistantMessage])) *Hook_OnAssistantMessage_Call

func (*Hook_OnAssistantMessage_Call) RunAndReturn 

func (_c *Hook_OnAssistantMessage_Call) RunAndReturn(run func(context.Context, messages.Message[messages.AssistantMessage])) *Hook_OnAssistantMessage_Call

type Hook_OnError_Call 

type Hook_OnError_Call struct {
	*mock.Call
}

Hook_OnError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnError'

func (*Hook_OnError_Call) Return 

func (_c *Hook_OnError_Call) Return() *Hook_OnError_Call

func (*Hook_OnError_Call) Run 

func (_c *Hook_OnError_Call) Run(run func(_a0 context.Context, _a1 error)) *Hook_OnError_Call

func (*Hook_OnError_Call) RunAndReturn 

func (_c *Hook_OnError_Call) RunAndReturn(run func(context.Context, error)) *Hook_OnError_Call

type Hook_OnToolCallChunk_Call 

type Hook_OnToolCallChunk_Call struct {
	*mock.Call
}

Hook_OnToolCallChunk_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnToolCallChunk'

func (*Hook_OnToolCallChunk_Call) Return 

func (_c *Hook_OnToolCallChunk_Call) Return() *Hook_OnToolCallChunk_Call

func (*Hook_OnToolCallChunk_Call) Run 

func (_c *Hook_OnToolCallChunk_Call) Run(run func(_a0 context.Context, _a1 messages.Message[messages.ToolCallMessage])) *Hook_OnToolCallChunk_Call

func (*Hook_OnToolCallChunk_Call) RunAndReturn 

func (_c *Hook_OnToolCallChunk_Call) RunAndReturn(run func(context.Context, messages.Message[messages.ToolCallMessage])) *Hook_OnToolCallChunk_Call

type Hook_OnToolCallMessage_Call 

type Hook_OnToolCallMessage_Call struct {
	*mock.Call
}

Hook_OnToolCallMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnToolCallMessage'

func (*Hook_OnToolCallMessage_Call) Return 

func (_c *Hook_OnToolCallMessage_Call) Return() *Hook_OnToolCallMessage_Call

func (*Hook_OnToolCallMessage_Call) Run 

func (_c *Hook_OnToolCallMessage_Call) Run(run func(_a0 context.Context, _a1 messages.Message[messages.ToolCallMessage])) *Hook_OnToolCallMessage_Call

func (*Hook_OnToolCallMessage_Call) RunAndReturn 

func (_c *Hook_OnToolCallMessage_Call) RunAndReturn(run func(context.Context, messages.Message[messages.ToolCallMessage])) *Hook_OnToolCallMessage_Call

type Hook_OnToolCallResponse_Call 

type Hook_OnToolCallResponse_Call struct {
	*mock.Call
}

Hook_OnToolCallResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnToolCallResponse'

func (*Hook_OnToolCallResponse_Call) Return 

func (_c *Hook_OnToolCallResponse_Call) Return() *Hook_OnToolCallResponse_Call

func (*Hook_OnToolCallResponse_Call) Run 

func (_c *Hook_OnToolCallResponse_Call) Run(run func(_a0 context.Context, _a1 messages.Message[messages.ToolResponse])) *Hook_OnToolCallResponse_Call

func (*Hook_OnToolCallResponse_Call) RunAndReturn 

func (_c *Hook_OnToolCallResponse_Call) RunAndReturn(run func(context.Context, messages.Message[messages.ToolResponse])) *Hook_OnToolCallResponse_Call

type Hook_OnUserPrompt_Call 

type Hook_OnUserPrompt_Call struct {
	*mock.Call
}

Hook_OnUserPrompt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnUserPrompt'

func (*Hook_OnUserPrompt_Call) Return 

func (_c *Hook_OnUserPrompt_Call) Return() *Hook_OnUserPrompt_Call

func (*Hook_OnUserPrompt_Call) Run 

func (_c *Hook_OnUserPrompt_Call) Run(run func(_a0 context.Context, _a1 messages.Message[messages.UserMessage])) *Hook_OnUserPrompt_Call

func (*Hook_OnUserPrompt_Call) RunAndReturn 

func (_c *Hook_OnUserPrompt_Call) RunAndReturn(run func(context.Context, messages.Message[messages.UserMessage])) *Hook_OnUserPrompt_Call

type Model 

type Model struct {
	mock.Mock
}

Model is an autogenerated mock type for the Model type

func NewModel 

func NewModel(t interface {
	mock.TestingT
	Cleanup(func())
},
) *Model

NewModel creates a new instance of Model. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*Model) EXPECT 

func (_m *Model) EXPECT() *Model_Expecter

func (*Model) Name 

func (_m *Model) Name() string

Name provides a mock function with no fields

func (*Model) Provider 

func (_m *Model) Provider() provider.Provider

Provider provides a mock function with no fields

type Model_Expecter 

type Model_Expecter struct {
	// contains filtered or unexported fields
}

func (*Model_Expecter) Name 

func (_e *Model_Expecter) Name() *Model_Name_Call

Name is a helper method to define mock.On call

func (*Model_Expecter) Provider 

func (_e *Model_Expecter) Provider() *Model_Provider_Call

Provider is a helper method to define mock.On call

type Model_Name_Call 

type Model_Name_Call struct {
	*mock.Call
}

Model_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name'

func (*Model_Name_Call) Return 

func (_c *Model_Name_Call) Return(_a0 string) *Model_Name_Call

func (*Model_Name_Call) Run 

func (_c *Model_Name_Call) Run(run func()) *Model_Name_Call

func (*Model_Name_Call) RunAndReturn 

func (_c *Model_Name_Call) RunAndReturn(run func() string) *Model_Name_Call

type Model_Provider_Call 

type Model_Provider_Call struct {
	*mock.Call
}

Model_Provider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Provider'

func (*Model_Provider_Call) Return 

func (_c *Model_Provider_Call) Return(_a0 provider.Provider) *Model_Provider_Call

func (*Model_Provider_Call) Run 

func (_c *Model_Provider_Call) Run(run func()) *Model_Provider_Call

func (*Model_Provider_Call) RunAndReturn 

func (_c *Model_Provider_Call) RunAndReturn(run func() provider.Provider) *Model_Provider_Call

type Provider 

type Provider struct {
	mock.Mock
}

Provider is an autogenerated mock type for the Provider type

func NewProvider 

func NewProvider(t interface {
	mock.TestingT
	Cleanup(func())
},
) *Provider

NewProvider creates a new instance of Provider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*Provider) ChatCompletion 

func (_m *Provider) ChatCompletion(_a0 context.Context, _a1 provider.CompletionParams) (<-chan provider.StreamEvent, error)

ChatCompletion provides a mock function with given fields: _a0, _a1

func (*Provider) EXPECT 

func (_m *Provider) EXPECT() *Provider_Expecter

type Provider_ChatCompletion_Call 

type Provider_ChatCompletion_Call struct {
	*mock.Call
}

Provider_ChatCompletion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChatCompletion'

func (*Provider_ChatCompletion_Call) Return 

func (_c *Provider_ChatCompletion_Call) Return(_a0 <-chan provider.StreamEvent, _a1 error) *Provider_ChatCompletion_Call

func (*Provider_ChatCompletion_Call) Run 

func (_c *Provider_ChatCompletion_Call) Run(run func(_a0 context.Context, _a1 provider.CompletionParams)) *Provider_ChatCompletion_Call

func (*Provider_ChatCompletion_Call) RunAndReturn 

func (_c *Provider_ChatCompletion_Call) RunAndReturn(run func(context.Context, provider.CompletionParams) (<-chan provider.StreamEvent, error)) *Provider_ChatCompletion_Call

type Provider_Expecter 

type Provider_Expecter struct {
	// contains filtered or unexported fields
}

func (*Provider_Expecter) ChatCompletion 

func (_e *Provider_Expecter) ChatCompletion(_a0 interface{}, _a1 interface{}) *Provider_ChatCompletion_Call

ChatCompletion is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 provider.CompletionParams

type Subscription 

type Subscription struct {
	mock.Mock
}

Subscription is an autogenerated mock type for the Subscription type

func NewSubscription 

func NewSubscription(t interface {
	mock.TestingT
	Cleanup(func())
},
) *Subscription

NewSubscription creates a new instance of Subscription. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*Subscription) EXPECT 

func (_m *Subscription) EXPECT() *Subscription_Expecter

func (*Subscription) ID 

func (_m *Subscription) ID() string

ID provides a mock function with no fields

func (*Subscription) Unsubscribe 

func (_m *Subscription) Unsubscribe()

Unsubscribe provides a mock function with no fields

type Subscription_Expecter 

type Subscription_Expecter struct {
	// contains filtered or unexported fields
}

func (*Subscription_Expecter) ID 

func (_e *Subscription_Expecter) ID() *Subscription_ID_Call

ID is a helper method to define mock.On call

func (*Subscription_Expecter) Unsubscribe 

func (_e *Subscription_Expecter) Unsubscribe() *Subscription_Unsubscribe_Call

Unsubscribe is a helper method to define mock.On call

type Subscription_ID_Call 

type Subscription_ID_Call struct {
	*mock.Call
}

Subscription_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'

func (*Subscription_ID_Call) Return 

func (_c *Subscription_ID_Call) Return(_a0 string) *Subscription_ID_Call

func (*Subscription_ID_Call) Run 

func (_c *Subscription_ID_Call) Run(run func()) *Subscription_ID_Call

func (*Subscription_ID_Call) RunAndReturn 

func (_c *Subscription_ID_Call) RunAndReturn(run func() string) *Subscription_ID_Call

type Subscription_Unsubscribe_Call 

type Subscription_Unsubscribe_Call struct {
	*mock.Call
}

Subscription_Unsubscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unsubscribe'

func (*Subscription_Unsubscribe_Call) Return 

func (_c *Subscription_Unsubscribe_Call) Return() *Subscription_Unsubscribe_Call

func (*Subscription_Unsubscribe_Call) Run 

func (_c *Subscription_Unsubscribe_Call) Run(run func()) *Subscription_Unsubscribe_Call

func (*Subscription_Unsubscribe_Call) RunAndReturn 

func (_c *Subscription_Unsubscribe_Call) RunAndReturn(run func()) *Subscription_Unsubscribe_Call

type Topic 

type Topic struct {
	mock.Mock
}

Topic is an autogenerated mock type for the Topic type

func NewTopic 

func NewTopic(t interface {
	mock.TestingT
	Cleanup(func())
},
) *Topic

NewTopic creates a new instance of Topic. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*Topic) EXPECT 

func (_m *Topic) EXPECT() *Topic_Expecter

func (*Topic) Publish 

func (_m *Topic) Publish(_a0 context.Context, _a1 events.Event) error

Publish provides a mock function with given fields: _a0, _a1

func (*Topic) Subscribe 

func (_m *Topic) Subscribe(_a0 context.Context, _a1 events.Hook) (broker.Subscription, error)

Subscribe provides a mock function with given fields: _a0, _a1

type Topic_Expecter 

type Topic_Expecter struct {
	// contains filtered or unexported fields
}

func (*Topic_Expecter) Publish 

func (_e *Topic_Expecter) Publish(_a0 interface{}, _a1 interface{}) *Topic_Publish_Call

Publish is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 events.Event

func (*Topic_Expecter) Subscribe 

func (_e *Topic_Expecter) Subscribe(_a0 interface{}, _a1 interface{}) *Topic_Subscribe_Call

Subscribe is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 events.Hook

type Topic_Publish_Call 

type Topic_Publish_Call struct {
	*mock.Call
}

Topic_Publish_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Publish'

func (*Topic_Publish_Call) Return 

func (_c *Topic_Publish_Call) Return(_a0 error) *Topic_Publish_Call

func (*Topic_Publish_Call) Run 

func (_c *Topic_Publish_Call) Run(run func(_a0 context.Context, _a1 events.Event)) *Topic_Publish_Call

func (*Topic_Publish_Call) RunAndReturn 

func (_c *Topic_Publish_Call) RunAndReturn(run func(context.Context, events.Event) error) *Topic_Publish_Call

type Topic_Subscribe_Call 

type Topic_Subscribe_Call struct {
	*mock.Call
}

Topic_Subscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Subscribe'

func (*Topic_Subscribe_Call) Return 

func (_c *Topic_Subscribe_Call) Return(_a0 broker.Subscription, _a1 error) *Topic_Subscribe_Call

func (*Topic_Subscribe_Call) Run 

func (_c *Topic_Subscribe_Call) Run(run func(_a0 context.Context, _a1 events.Hook)) *Topic_Subscribe_Call

func (*Topic_Subscribe_Call) RunAndReturn 

func (_c *Topic_Subscribe_Call) RunAndReturn(run func(context.Context, events.Hook) (broker.Subscription, error)) *Topic_Subscribe_Call

type WorkflowRun 

type WorkflowRun struct {
	mock.Mock
}

WorkflowRun is an autogenerated mock type for the WorkflowRun type

func NewWorkflowRun 

func NewWorkflowRun(t interface {
	mock.TestingT
	Cleanup(func())
},
) *WorkflowRun

NewWorkflowRun creates a new instance of WorkflowRun. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*WorkflowRun) EXPECT 

func (_m *WorkflowRun) EXPECT() *WorkflowRun_Expecter

func (*WorkflowRun) Get 

func (_m *WorkflowRun) Get(ctx context.Context, valuePtr interface{}) error

Get provides a mock function with given fields: ctx, valuePtr

func (*WorkflowRun) GetID 

func (_m *WorkflowRun) GetID() string

GetID provides a mock function with no fields

func (*WorkflowRun) GetRunID 

func (_m *WorkflowRun) GetRunID() string

GetRunID provides a mock function with no fields

func (*WorkflowRun) GetWithOptions 

func (_m *WorkflowRun) GetWithOptions(ctx context.Context, valuePtr interface{}, options client.WorkflowRunGetOptions) error

GetWithOptions provides a mock function with given fields: ctx, valuePtr, options

type WorkflowRun_Expecter 

type WorkflowRun_Expecter struct {
	// contains filtered or unexported fields
}

func (*WorkflowRun_Expecter) Get 

func (_e *WorkflowRun_Expecter) Get(ctx interface{}, valuePtr interface{}) *WorkflowRun_Get_Call

Get is a helper method to define mock.On call

  • ctx context.Context
  • valuePtr interface{}

func (*WorkflowRun_Expecter) GetID 

func (_e *WorkflowRun_Expecter) GetID() *WorkflowRun_GetID_Call

GetID is a helper method to define mock.On call

func (*WorkflowRun_Expecter) GetRunID 

func (_e *WorkflowRun_Expecter) GetRunID() *WorkflowRun_GetRunID_Call

GetRunID is a helper method to define mock.On call

func (*WorkflowRun_Expecter) GetWithOptions 

func (_e *WorkflowRun_Expecter) GetWithOptions(ctx interface{}, valuePtr interface{}, options interface{}) *WorkflowRun_GetWithOptions_Call

GetWithOptions is a helper method to define mock.On call

  • ctx context.Context
  • valuePtr interface{}
  • options client.WorkflowRunGetOptions

type WorkflowRun_GetID_Call 

type WorkflowRun_GetID_Call struct {
	*mock.Call
}

WorkflowRun_GetID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetID'

func (*WorkflowRun_GetID_Call) Return 

func (_c *WorkflowRun_GetID_Call) Return(_a0 string) *WorkflowRun_GetID_Call

func (*WorkflowRun_GetID_Call) Run 

func (_c *WorkflowRun_GetID_Call) Run(run func()) *WorkflowRun_GetID_Call

func (*WorkflowRun_GetID_Call) RunAndReturn 

func (_c *WorkflowRun_GetID_Call) RunAndReturn(run func() string) *WorkflowRun_GetID_Call

type WorkflowRun_GetRunID_Call 

type WorkflowRun_GetRunID_Call struct {
	*mock.Call
}

WorkflowRun_GetRunID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRunID'

func (*WorkflowRun_GetRunID_Call) Return 

func (_c *WorkflowRun_GetRunID_Call) Return(_a0 string) *WorkflowRun_GetRunID_Call

func (*WorkflowRun_GetRunID_Call) Run 

func (_c *WorkflowRun_GetRunID_Call) Run(run func()) *WorkflowRun_GetRunID_Call

func (*WorkflowRun_GetRunID_Call) RunAndReturn 

func (_c *WorkflowRun_GetRunID_Call) RunAndReturn(run func() string) *WorkflowRun_GetRunID_Call

type WorkflowRun_GetWithOptions_Call 

type WorkflowRun_GetWithOptions_Call struct {
	*mock.Call
}

WorkflowRun_GetWithOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWithOptions'

func (*WorkflowRun_GetWithOptions_Call) Return 

func (_c *WorkflowRun_GetWithOptions_Call) Return(_a0 error) *WorkflowRun_GetWithOptions_Call

func (*WorkflowRun_GetWithOptions_Call) Run 

func (_c *WorkflowRun_GetWithOptions_Call) Run(run func(ctx context.Context, valuePtr interface{}, options client.WorkflowRunGetOptions)) *WorkflowRun_GetWithOptions_Call

func (*WorkflowRun_GetWithOptions_Call) RunAndReturn 

func (_c *WorkflowRun_GetWithOptions_Call) RunAndReturn(run func(context.Context, interface{}, client.WorkflowRunGetOptions) error) *WorkflowRun_GetWithOptions_Call

type WorkflowRun_Get_Call 

type WorkflowRun_Get_Call struct {
	*mock.Call
}

WorkflowRun_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*WorkflowRun_Get_Call) Return 

func (_c *WorkflowRun_Get_Call) Return(_a0 error) *WorkflowRun_Get_Call

func (*WorkflowRun_Get_Call) Run 

func (_c *WorkflowRun_Get_Call) Run(run func(ctx context.Context, valuePtr interface{})) *WorkflowRun_Get_Call

func (*WorkflowRun_Get_Call) RunAndReturn 

func (_c *WorkflowRun_Get_Call) RunAndReturn(run func(context.Context, interface{}) error) *WorkflowRun_Get_Call

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.