mocks

package
v0.23.0 Latest Latest
Warning

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

 Go to latest Published: Aug 30, 2024 License: MIT Imports: 3 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AcknowledgeableInput 

type AcknowledgeableInput struct {
	mock.Mock
}

AcknowledgeableInput is an autogenerated mock type for the AcknowledgeableInput type

func NewAcknowledgeableInput 

func NewAcknowledgeableInput(t interface {
	mock.TestingT
	Cleanup(func())
}) *AcknowledgeableInput

NewAcknowledgeableInput creates a new instance of AcknowledgeableInput. 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 (*AcknowledgeableInput) Ack 

func (_m *AcknowledgeableInput) Ack(ctx context.Context, msg *stream.Message, ack bool) error

Ack provides a mock function with given fields: ctx, msg, ack

func (*AcknowledgeableInput) AckBatch 

func (_m *AcknowledgeableInput) AckBatch(ctx context.Context, msgs []*stream.Message, acks []bool) error

AckBatch provides a mock function with given fields: ctx, msgs, acks

func (*AcknowledgeableInput) Data 

func (_m *AcknowledgeableInput) Data() <-chan *stream.Message

Data provides a mock function with given fields:

func (*AcknowledgeableInput) EXPECT 

func (_m *AcknowledgeableInput) EXPECT() *AcknowledgeableInput_Expecter

func (*AcknowledgeableInput) Run 

func (_m *AcknowledgeableInput) Run(ctx context.Context) error

Run provides a mock function with given fields: ctx

func (*AcknowledgeableInput) Stop 

func (_m *AcknowledgeableInput) Stop()

Stop provides a mock function with given fields:

type AcknowledgeableInput_AckBatch_Call 

type AcknowledgeableInput_AckBatch_Call struct {
	*mock.Call
}

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

func (*AcknowledgeableInput_AckBatch_Call) Return 

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

func (*AcknowledgeableInput_AckBatch_Call) Run 

func (_c *AcknowledgeableInput_AckBatch_Call) Run(run func(ctx context.Context, msgs []*stream.Message, acks []bool)) *AcknowledgeableInput_AckBatch_Call

func (*AcknowledgeableInput_AckBatch_Call) RunAndReturn 

func (_c *AcknowledgeableInput_AckBatch_Call) RunAndReturn(run func(context.Context, []*stream.Message, []bool) error) *AcknowledgeableInput_AckBatch_Call

type AcknowledgeableInput_Ack_Call 

type AcknowledgeableInput_Ack_Call struct {
	*mock.Call
}

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

func (*AcknowledgeableInput_Ack_Call) Return 

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

func (*AcknowledgeableInput_Ack_Call) Run 

func (_c *AcknowledgeableInput_Ack_Call) Run(run func(ctx context.Context, msg *stream.Message, ack bool)) *AcknowledgeableInput_Ack_Call

func (*AcknowledgeableInput_Ack_Call) RunAndReturn 

func (_c *AcknowledgeableInput_Ack_Call) RunAndReturn(run func(context.Context, *stream.Message, bool) error) *AcknowledgeableInput_Ack_Call

type AcknowledgeableInput_Data_Call 

type AcknowledgeableInput_Data_Call struct {
	*mock.Call
}

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

func (*AcknowledgeableInput_Data_Call) Return 

func (_c *AcknowledgeableInput_Data_Call) Return(_a0 <-chan *stream.Message) *AcknowledgeableInput_Data_Call

func (*AcknowledgeableInput_Data_Call) Run 

func (_c *AcknowledgeableInput_Data_Call) Run(run func()) *AcknowledgeableInput_Data_Call

func (*AcknowledgeableInput_Data_Call) RunAndReturn 

func (_c *AcknowledgeableInput_Data_Call) RunAndReturn(run func() <-chan *stream.Message) *AcknowledgeableInput_Data_Call

type AcknowledgeableInput_Expecter 

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

func (*AcknowledgeableInput_Expecter) Ack 

func (_e *AcknowledgeableInput_Expecter) Ack(ctx interface{}, msg interface{}, ack interface{}) *AcknowledgeableInput_Ack_Call

Ack is a helper method to define mock.On call

  • ctx context.Context
  • msg *stream.Message
  • ack bool

func (*AcknowledgeableInput_Expecter) AckBatch 

func (_e *AcknowledgeableInput_Expecter) AckBatch(ctx interface{}, msgs interface{}, acks interface{}) *AcknowledgeableInput_AckBatch_Call

AckBatch is a helper method to define mock.On call

  • ctx context.Context
  • msgs []*stream.Message
  • acks []bool

func (*AcknowledgeableInput_Expecter) Data 

func (_e *AcknowledgeableInput_Expecter) Data() *AcknowledgeableInput_Data_Call

Data is a helper method to define mock.On call

func (*AcknowledgeableInput_Expecter) Run 

func (_e *AcknowledgeableInput_Expecter) Run(ctx interface{}) *AcknowledgeableInput_Run_Call

Run is a helper method to define mock.On call

  • ctx context.Context

func (*AcknowledgeableInput_Expecter) Stop 

func (_e *AcknowledgeableInput_Expecter) Stop() *AcknowledgeableInput_Stop_Call

Stop is a helper method to define mock.On call

type AcknowledgeableInput_Run_Call 

type AcknowledgeableInput_Run_Call struct {
	*mock.Call
}

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

func (*AcknowledgeableInput_Run_Call) Return 

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

func (*AcknowledgeableInput_Run_Call) Run 

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

func (*AcknowledgeableInput_Run_Call) RunAndReturn 

func (_c *AcknowledgeableInput_Run_Call) RunAndReturn(run func(context.Context) error) *AcknowledgeableInput_Run_Call

type AcknowledgeableInput_Stop_Call 

type AcknowledgeableInput_Stop_Call struct {
	*mock.Call
}

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

func (*AcknowledgeableInput_Stop_Call) Return 

func (_c *AcknowledgeableInput_Stop_Call) Return() *AcknowledgeableInput_Stop_Call

func (*AcknowledgeableInput_Stop_Call) Run 

func (_c *AcknowledgeableInput_Stop_Call) Run(run func()) *AcknowledgeableInput_Stop_Call

func (*AcknowledgeableInput_Stop_Call) RunAndReturn 

func (_c *AcknowledgeableInput_Stop_Call) RunAndReturn(run func()) *AcknowledgeableInput_Stop_Call

type BatchConsumerCallback 

type BatchConsumerCallback struct {
	mock.Mock
}

BatchConsumerCallback is an autogenerated mock type for the BatchConsumerCallback type

func NewBatchConsumerCallback 

func NewBatchConsumerCallback(t interface {
	mock.TestingT
	Cleanup(func())
}) *BatchConsumerCallback

NewBatchConsumerCallback creates a new instance of BatchConsumerCallback. 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 (*BatchConsumerCallback) Consume 

func (_m *BatchConsumerCallback) Consume(ctx context.Context, models []interface{}, attributes []map[string]string) ([]bool, error)

Consume provides a mock function with given fields: ctx, models, attributes

func (*BatchConsumerCallback) EXPECT 

func (_m *BatchConsumerCallback) EXPECT() *BatchConsumerCallback_Expecter

func (*BatchConsumerCallback) GetModel 

func (_m *BatchConsumerCallback) GetModel(attributes map[string]string) interface{}

GetModel provides a mock function with given fields: attributes

type BatchConsumerCallback_Consume_Call 

type BatchConsumerCallback_Consume_Call struct {
	*mock.Call
}

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

func (*BatchConsumerCallback_Consume_Call) Return 

func (_c *BatchConsumerCallback_Consume_Call) Return(_a0 []bool, _a1 error) *BatchConsumerCallback_Consume_Call

func (*BatchConsumerCallback_Consume_Call) Run 

func (_c *BatchConsumerCallback_Consume_Call) Run(run func(ctx context.Context, models []interface{}, attributes []map[string]string)) *BatchConsumerCallback_Consume_Call

func (*BatchConsumerCallback_Consume_Call) RunAndReturn 

func (_c *BatchConsumerCallback_Consume_Call) RunAndReturn(run func(context.Context, []interface{}, []map[string]string) ([]bool, error)) *BatchConsumerCallback_Consume_Call

type BatchConsumerCallback_Expecter 

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

func (*BatchConsumerCallback_Expecter) Consume 

func (_e *BatchConsumerCallback_Expecter) Consume(ctx interface{}, models interface{}, attributes interface{}) *BatchConsumerCallback_Consume_Call

Consume is a helper method to define mock.On call

  • ctx context.Context
  • models []interface{}
  • attributes []map[string]string

func (*BatchConsumerCallback_Expecter) GetModel 

func (_e *BatchConsumerCallback_Expecter) GetModel(attributes interface{}) *BatchConsumerCallback_GetModel_Call

GetModel is a helper method to define mock.On call

  • attributes map[string]string

type BatchConsumerCallback_GetModel_Call 

type BatchConsumerCallback_GetModel_Call struct {
	*mock.Call
}

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

func (*BatchConsumerCallback_GetModel_Call) Return 

func (_c *BatchConsumerCallback_GetModel_Call) Return(_a0 interface{}) *BatchConsumerCallback_GetModel_Call

func (*BatchConsumerCallback_GetModel_Call) Run 

func (_c *BatchConsumerCallback_GetModel_Call) Run(run func(attributes map[string]string)) *BatchConsumerCallback_GetModel_Call

func (*BatchConsumerCallback_GetModel_Call) RunAndReturn 

func (_c *BatchConsumerCallback_GetModel_Call) RunAndReturn(run func(map[string]string) interface{}) *BatchConsumerCallback_GetModel_Call

type ConsumerCallback 

type ConsumerCallback struct {
	mock.Mock
}

ConsumerCallback is an autogenerated mock type for the ConsumerCallback type

func NewConsumerCallback 

func NewConsumerCallback(t interface {
	mock.TestingT
	Cleanup(func())
}) *ConsumerCallback

NewConsumerCallback creates a new instance of ConsumerCallback. 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 (*ConsumerCallback) Consume 

func (_m *ConsumerCallback) Consume(ctx context.Context, model interface{}, attributes map[string]string) (bool, error)

Consume provides a mock function with given fields: ctx, model, attributes

func (*ConsumerCallback) EXPECT 

func (_m *ConsumerCallback) EXPECT() *ConsumerCallback_Expecter

func (*ConsumerCallback) GetModel 

func (_m *ConsumerCallback) GetModel(attributes map[string]string) interface{}

GetModel provides a mock function with given fields: attributes

type ConsumerCallback_Consume_Call 

type ConsumerCallback_Consume_Call struct {
	*mock.Call
}

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

func (*ConsumerCallback_Consume_Call) Return 

func (_c *ConsumerCallback_Consume_Call) Return(_a0 bool, _a1 error) *ConsumerCallback_Consume_Call

func (*ConsumerCallback_Consume_Call) Run 

func (_c *ConsumerCallback_Consume_Call) Run(run func(ctx context.Context, model interface{}, attributes map[string]string)) *ConsumerCallback_Consume_Call

func (*ConsumerCallback_Consume_Call) RunAndReturn 

func (_c *ConsumerCallback_Consume_Call) RunAndReturn(run func(context.Context, interface{}, map[string]string) (bool, error)) *ConsumerCallback_Consume_Call

type ConsumerCallback_Expecter 

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

func (*ConsumerCallback_Expecter) Consume 

func (_e *ConsumerCallback_Expecter) Consume(ctx interface{}, model interface{}, attributes interface{}) *ConsumerCallback_Consume_Call

Consume is a helper method to define mock.On call

  • ctx context.Context
  • model interface{}
  • attributes map[string]string

func (*ConsumerCallback_Expecter) GetModel 

func (_e *ConsumerCallback_Expecter) GetModel(attributes interface{}) *ConsumerCallback_GetModel_Call

GetModel is a helper method to define mock.On call

  • attributes map[string]string

type ConsumerCallback_GetModel_Call 

type ConsumerCallback_GetModel_Call struct {
	*mock.Call
}

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

func (*ConsumerCallback_GetModel_Call) Return 

func (_c *ConsumerCallback_GetModel_Call) Return(_a0 interface{}) *ConsumerCallback_GetModel_Call

func (*ConsumerCallback_GetModel_Call) Run 

func (_c *ConsumerCallback_GetModel_Call) Run(run func(attributes map[string]string)) *ConsumerCallback_GetModel_Call

func (*ConsumerCallback_GetModel_Call) RunAndReturn 

func (_c *ConsumerCallback_GetModel_Call) RunAndReturn(run func(map[string]string) interface{}) *ConsumerCallback_GetModel_Call

type Input 

type Input struct {
	mock.Mock
}

Input is an autogenerated mock type for the Input type

func NewInput 

func NewInput(t interface {
	mock.TestingT
	Cleanup(func())
}) *Input

NewInput creates a new instance of Input. 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 (*Input) Data 

func (_m *Input) Data() <-chan *stream.Message

Data provides a mock function with given fields:

func (*Input) EXPECT 

func (_m *Input) EXPECT() *Input_Expecter

func (*Input) Run 

func (_m *Input) Run(ctx context.Context) error

Run provides a mock function with given fields: ctx

func (*Input) Stop 

func (_m *Input) Stop()

Stop provides a mock function with given fields:

type Input_Data_Call 

type Input_Data_Call struct {
	*mock.Call
}

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

func (*Input_Data_Call) Return 

func (_c *Input_Data_Call) Return(_a0 <-chan *stream.Message) *Input_Data_Call

func (*Input_Data_Call) Run 

func (_c *Input_Data_Call) Run(run func()) *Input_Data_Call

func (*Input_Data_Call) RunAndReturn 

func (_c *Input_Data_Call) RunAndReturn(run func() <-chan *stream.Message) *Input_Data_Call

type Input_Expecter 

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

func (*Input_Expecter) Data 

func (_e *Input_Expecter) Data() *Input_Data_Call

Data is a helper method to define mock.On call

func (*Input_Expecter) Run 

func (_e *Input_Expecter) Run(ctx interface{}) *Input_Run_Call

Run is a helper method to define mock.On call

  • ctx context.Context

func (*Input_Expecter) Stop 

func (_e *Input_Expecter) Stop() *Input_Stop_Call

Stop is a helper method to define mock.On call

type Input_Run_Call 

type Input_Run_Call struct {
	*mock.Call
}

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

func (*Input_Run_Call) Return 

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

func (*Input_Run_Call) Run 

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

func (*Input_Run_Call) RunAndReturn 

func (_c *Input_Run_Call) RunAndReturn(run func(context.Context) error) *Input_Run_Call

type Input_Stop_Call 

type Input_Stop_Call struct {
	*mock.Call
}

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

func (*Input_Stop_Call) Return 

func (_c *Input_Stop_Call) Return() *Input_Stop_Call

func (*Input_Stop_Call) Run 

func (_c *Input_Stop_Call) Run(run func()) *Input_Stop_Call

func (*Input_Stop_Call) RunAndReturn 

func (_c *Input_Stop_Call) RunAndReturn(run func()) *Input_Stop_Call

type MessageEncoder 

type MessageEncoder struct {
	mock.Mock
}

MessageEncoder is an autogenerated mock type for the MessageEncoder type

func NewMessageEncoder 

func NewMessageEncoder(t interface {
	mock.TestingT
	Cleanup(func())
}) *MessageEncoder

NewMessageEncoder creates a new instance of MessageEncoder. 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 (*MessageEncoder) Decode 

func (_m *MessageEncoder) Decode(ctx context.Context, msg *stream.Message, out interface{}) (context.Context, map[string]string, error)

Decode provides a mock function with given fields: ctx, msg, out

func (*MessageEncoder) EXPECT 

func (_m *MessageEncoder) EXPECT() *MessageEncoder_Expecter

func (*MessageEncoder) Encode 

func (_m *MessageEncoder) Encode(ctx context.Context, data interface{}, attributeSets ...map[string]string) (*stream.Message, error)

Encode provides a mock function with given fields: ctx, data, attributeSets

type MessageEncoder_Decode_Call 

type MessageEncoder_Decode_Call struct {
	*mock.Call
}

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

func (*MessageEncoder_Decode_Call) Return 

func (_c *MessageEncoder_Decode_Call) Return(_a0 context.Context, _a1 map[string]string, _a2 error) *MessageEncoder_Decode_Call

func (*MessageEncoder_Decode_Call) Run 

func (_c *MessageEncoder_Decode_Call) Run(run func(ctx context.Context, msg *stream.Message, out interface{})) *MessageEncoder_Decode_Call

func (*MessageEncoder_Decode_Call) RunAndReturn 

func (_c *MessageEncoder_Decode_Call) RunAndReturn(run func(context.Context, *stream.Message, interface{}) (context.Context, map[string]string, error)) *MessageEncoder_Decode_Call

type MessageEncoder_Encode_Call 

type MessageEncoder_Encode_Call struct {
	*mock.Call
}

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

func (*MessageEncoder_Encode_Call) Return 

func (_c *MessageEncoder_Encode_Call) Return(_a0 *stream.Message, _a1 error) *MessageEncoder_Encode_Call

func (*MessageEncoder_Encode_Call) Run 

func (_c *MessageEncoder_Encode_Call) Run(run func(ctx context.Context, data interface{}, attributeSets ...map[string]string)) *MessageEncoder_Encode_Call

func (*MessageEncoder_Encode_Call) RunAndReturn 

func (_c *MessageEncoder_Encode_Call) RunAndReturn(run func(context.Context, interface{}, ...map[string]string) (*stream.Message, error)) *MessageEncoder_Encode_Call

type MessageEncoder_Expecter 

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

func (*MessageEncoder_Expecter) Decode 

func (_e *MessageEncoder_Expecter) Decode(ctx interface{}, msg interface{}, out interface{}) *MessageEncoder_Decode_Call

Decode is a helper method to define mock.On call

  • ctx context.Context
  • msg *stream.Message
  • out interface{}

func (*MessageEncoder_Expecter) Encode 

func (_e *MessageEncoder_Expecter) Encode(ctx interface{}, data interface{}, attributeSets ...interface{}) *MessageEncoder_Encode_Call

Encode is a helper method to define mock.On call

  • ctx context.Context
  • data interface{}
  • attributeSets ...map[string]string

type Output 

type Output struct {
	mock.Mock
}

Output is an autogenerated mock type for the Output type

func NewOutput 

func NewOutput(t interface {
	mock.TestingT
	Cleanup(func())
}) *Output

NewOutput creates a new instance of Output. 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 (*Output) EXPECT 

func (_m *Output) EXPECT() *Output_Expecter

func (*Output) Write 

func (_m *Output) Write(ctx context.Context, batch []stream.WritableMessage) error

Write provides a mock function with given fields: ctx, batch

func (*Output) WriteOne 

func (_m *Output) WriteOne(ctx context.Context, msg stream.WritableMessage) error

WriteOne provides a mock function with given fields: ctx, msg

type Output_Expecter 

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

func (*Output_Expecter) Write 

func (_e *Output_Expecter) Write(ctx interface{}, batch interface{}) *Output_Write_Call

Write is a helper method to define mock.On call

  • ctx context.Context
  • batch []stream.WritableMessage

func (*Output_Expecter) WriteOne 

func (_e *Output_Expecter) WriteOne(ctx interface{}, msg interface{}) *Output_WriteOne_Call

WriteOne is a helper method to define mock.On call

  • ctx context.Context
  • msg stream.WritableMessage

type Output_WriteOne_Call 

type Output_WriteOne_Call struct {
	*mock.Call
}

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

func (*Output_WriteOne_Call) Return 

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

func (*Output_WriteOne_Call) Run 

func (_c *Output_WriteOne_Call) Run(run func(ctx context.Context, msg stream.WritableMessage)) *Output_WriteOne_Call

func (*Output_WriteOne_Call) RunAndReturn 

func (_c *Output_WriteOne_Call) RunAndReturn(run func(context.Context, stream.WritableMessage) error) *Output_WriteOne_Call

type Output_Write_Call 

type Output_Write_Call struct {
	*mock.Call
}

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

func (*Output_Write_Call) Return 

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

func (*Output_Write_Call) Run 

func (_c *Output_Write_Call) Run(run func(ctx context.Context, batch []stream.WritableMessage)) *Output_Write_Call

func (*Output_Write_Call) RunAndReturn 

func (_c *Output_Write_Call) RunAndReturn(run func(context.Context, []stream.WritableMessage) error) *Output_Write_Call

type PartitionedOutput 

type PartitionedOutput struct {
	mock.Mock
}

PartitionedOutput is an autogenerated mock type for the PartitionedOutput type

func NewPartitionedOutput 

func NewPartitionedOutput(t interface {
	mock.TestingT
	Cleanup(func())
}) *PartitionedOutput

NewPartitionedOutput creates a new instance of PartitionedOutput. 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 (*PartitionedOutput) EXPECT 

func (_m *PartitionedOutput) EXPECT() *PartitionedOutput_Expecter

func (*PartitionedOutput) IsPartitionedOutput 

func (_m *PartitionedOutput) IsPartitionedOutput() bool

IsPartitionedOutput provides a mock function with given fields:

func (*PartitionedOutput) Write 

func (_m *PartitionedOutput) Write(ctx context.Context, batch []stream.WritableMessage) error

Write provides a mock function with given fields: ctx, batch

func (*PartitionedOutput) WriteOne 

func (_m *PartitionedOutput) WriteOne(ctx context.Context, msg stream.WritableMessage) error

WriteOne provides a mock function with given fields: ctx, msg

type PartitionedOutput_Expecter 

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

func (*PartitionedOutput_Expecter) IsPartitionedOutput 

func (_e *PartitionedOutput_Expecter) IsPartitionedOutput() *PartitionedOutput_IsPartitionedOutput_Call

IsPartitionedOutput is a helper method to define mock.On call

func (*PartitionedOutput_Expecter) Write 

func (_e *PartitionedOutput_Expecter) Write(ctx interface{}, batch interface{}) *PartitionedOutput_Write_Call

Write is a helper method to define mock.On call

  • ctx context.Context
  • batch []stream.WritableMessage

func (*PartitionedOutput_Expecter) WriteOne 

func (_e *PartitionedOutput_Expecter) WriteOne(ctx interface{}, msg interface{}) *PartitionedOutput_WriteOne_Call

WriteOne is a helper method to define mock.On call

  • ctx context.Context
  • msg stream.WritableMessage

type PartitionedOutput_IsPartitionedOutput_Call 

type PartitionedOutput_IsPartitionedOutput_Call struct {
	*mock.Call
}

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

func (*PartitionedOutput_IsPartitionedOutput_Call) Return 

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

func (*PartitionedOutput_IsPartitionedOutput_Call) Run 

func (_c *PartitionedOutput_IsPartitionedOutput_Call) Run(run func()) *PartitionedOutput_IsPartitionedOutput_Call

func (*PartitionedOutput_IsPartitionedOutput_Call) RunAndReturn 

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

type PartitionedOutput_WriteOne_Call 

type PartitionedOutput_WriteOne_Call struct {
	*mock.Call
}

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

func (*PartitionedOutput_WriteOne_Call) Return 

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

func (*PartitionedOutput_WriteOne_Call) Run 

func (_c *PartitionedOutput_WriteOne_Call) Run(run func(ctx context.Context, msg stream.WritableMessage)) *PartitionedOutput_WriteOne_Call

func (*PartitionedOutput_WriteOne_Call) RunAndReturn 

func (_c *PartitionedOutput_WriteOne_Call) RunAndReturn(run func(context.Context, stream.WritableMessage) error) *PartitionedOutput_WriteOne_Call

type PartitionedOutput_Write_Call 

type PartitionedOutput_Write_Call struct {
	*mock.Call
}

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

func (*PartitionedOutput_Write_Call) Return 

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

func (*PartitionedOutput_Write_Call) Run 

func (_c *PartitionedOutput_Write_Call) Run(run func(ctx context.Context, batch []stream.WritableMessage)) *PartitionedOutput_Write_Call

func (*PartitionedOutput_Write_Call) RunAndReturn 

func (_c *PartitionedOutput_Write_Call) RunAndReturn(run func(context.Context, []stream.WritableMessage) error) *PartitionedOutput_Write_Call

type PartitionerRand 

type PartitionerRand struct {
	mock.Mock
}

PartitionerRand is an autogenerated mock type for the PartitionerRand type

func NewPartitionerRand 

func NewPartitionerRand(t interface {
	mock.TestingT
	Cleanup(func())
}) *PartitionerRand

NewPartitionerRand creates a new instance of PartitionerRand. 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 (*PartitionerRand) EXPECT 

func (_m *PartitionerRand) EXPECT() *PartitionerRand_Expecter

func (*PartitionerRand) Intn 

func (_m *PartitionerRand) Intn(n int) int

Intn provides a mock function with given fields: n

type PartitionerRand_Expecter 

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

func (*PartitionerRand_Expecter) Intn 

func (_e *PartitionerRand_Expecter) Intn(n interface{}) *PartitionerRand_Intn_Call

Intn is a helper method to define mock.On call

  • n int

type PartitionerRand_Intn_Call 

type PartitionerRand_Intn_Call struct {
	*mock.Call
}

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

func (*PartitionerRand_Intn_Call) Return 

func (_c *PartitionerRand_Intn_Call) Return(_a0 int) *PartitionerRand_Intn_Call

func (*PartitionerRand_Intn_Call) Run 

func (_c *PartitionerRand_Intn_Call) Run(run func(n int)) *PartitionerRand_Intn_Call

func (*PartitionerRand_Intn_Call) RunAndReturn 

func (_c *PartitionerRand_Intn_Call) RunAndReturn(run func(int) int) *PartitionerRand_Intn_Call

type Producer 

type Producer struct {
	mock.Mock
}

Producer is an autogenerated mock type for the Producer type

func NewProducer 

func NewProducer(t interface {
	mock.TestingT
	Cleanup(func())
}) *Producer

NewProducer creates a new instance of Producer. 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 (*Producer) EXPECT 

func (_m *Producer) EXPECT() *Producer_Expecter

func (*Producer) Write 

func (_m *Producer) Write(ctx context.Context, models interface{}, attributeSets ...map[string]string) error

Write provides a mock function with given fields: ctx, models, attributeSets

func (*Producer) WriteOne 

func (_m *Producer) WriteOne(ctx context.Context, model interface{}, attributeSets ...map[string]string) error

WriteOne provides a mock function with given fields: ctx, model, attributeSets

type ProducerDaemonAggregator 

type ProducerDaemonAggregator struct {
	mock.Mock
}

ProducerDaemonAggregator is an autogenerated mock type for the ProducerDaemonAggregator type

func NewProducerDaemonAggregator 

func NewProducerDaemonAggregator(t interface {
	mock.TestingT
	Cleanup(func())
}) *ProducerDaemonAggregator

NewProducerDaemonAggregator creates a new instance of ProducerDaemonAggregator. 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 (*ProducerDaemonAggregator) EXPECT 

func (_m *ProducerDaemonAggregator) EXPECT() *ProducerDaemonAggregator_Expecter

func (*ProducerDaemonAggregator) Flush 

func (_m *ProducerDaemonAggregator) Flush() ([]stream.AggregateFlush, error)

Flush provides a mock function with given fields:

func (*ProducerDaemonAggregator) Write 

func (_m *ProducerDaemonAggregator) Write(ctx context.Context, msg *stream.Message) ([]stream.AggregateFlush, error)

Write provides a mock function with given fields: ctx, msg

type ProducerDaemonAggregator_Expecter 

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

func (*ProducerDaemonAggregator_Expecter) Flush 

func (_e *ProducerDaemonAggregator_Expecter) Flush() *ProducerDaemonAggregator_Flush_Call

Flush is a helper method to define mock.On call

func (*ProducerDaemonAggregator_Expecter) Write 

func (_e *ProducerDaemonAggregator_Expecter) Write(ctx interface{}, msg interface{}) *ProducerDaemonAggregator_Write_Call

Write is a helper method to define mock.On call

  • ctx context.Context
  • msg *stream.Message

type ProducerDaemonAggregator_Flush_Call 

type ProducerDaemonAggregator_Flush_Call struct {
	*mock.Call
}

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

func (*ProducerDaemonAggregator_Flush_Call) Return 

func (_c *ProducerDaemonAggregator_Flush_Call) Return(_a0 []stream.AggregateFlush, _a1 error) *ProducerDaemonAggregator_Flush_Call

func (*ProducerDaemonAggregator_Flush_Call) Run 

func (_c *ProducerDaemonAggregator_Flush_Call) Run(run func()) *ProducerDaemonAggregator_Flush_Call

func (*ProducerDaemonAggregator_Flush_Call) RunAndReturn 

func (_c *ProducerDaemonAggregator_Flush_Call) RunAndReturn(run func() ([]stream.AggregateFlush, error)) *ProducerDaemonAggregator_Flush_Call

type ProducerDaemonAggregator_Write_Call 

type ProducerDaemonAggregator_Write_Call struct {
	*mock.Call
}

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

func (*ProducerDaemonAggregator_Write_Call) Return 

func (_c *ProducerDaemonAggregator_Write_Call) Return(_a0 []stream.AggregateFlush, _a1 error) *ProducerDaemonAggregator_Write_Call

func (*ProducerDaemonAggregator_Write_Call) Run 

func (_c *ProducerDaemonAggregator_Write_Call) Run(run func(ctx context.Context, msg *stream.Message)) *ProducerDaemonAggregator_Write_Call

func (*ProducerDaemonAggregator_Write_Call) RunAndReturn 

func (_c *ProducerDaemonAggregator_Write_Call) RunAndReturn(run func(context.Context, *stream.Message) ([]stream.AggregateFlush, error)) *ProducerDaemonAggregator_Write_Call

type ProducerDaemonBatcher 

type ProducerDaemonBatcher struct {
	mock.Mock
}

ProducerDaemonBatcher is an autogenerated mock type for the ProducerDaemonBatcher type

func NewProducerDaemonBatcher 

func NewProducerDaemonBatcher(t interface {
	mock.TestingT
	Cleanup(func())
}) *ProducerDaemonBatcher

NewProducerDaemonBatcher creates a new instance of ProducerDaemonBatcher. 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 (*ProducerDaemonBatcher) Append 

func (_m *ProducerDaemonBatcher) Append(msg *stream.Message) ([]stream.WritableMessage, error)

Append provides a mock function with given fields: msg

func (*ProducerDaemonBatcher) EXPECT 

func (_m *ProducerDaemonBatcher) EXPECT() *ProducerDaemonBatcher_Expecter

func (*ProducerDaemonBatcher) Flush 

func (_m *ProducerDaemonBatcher) Flush() []stream.WritableMessage

Flush provides a mock function with given fields:

type ProducerDaemonBatcher_Append_Call 

type ProducerDaemonBatcher_Append_Call struct {
	*mock.Call
}

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

func (*ProducerDaemonBatcher_Append_Call) Return 

func (_c *ProducerDaemonBatcher_Append_Call) Return(_a0 []stream.WritableMessage, _a1 error) *ProducerDaemonBatcher_Append_Call

func (*ProducerDaemonBatcher_Append_Call) Run 

func (_c *ProducerDaemonBatcher_Append_Call) Run(run func(msg *stream.Message)) *ProducerDaemonBatcher_Append_Call

func (*ProducerDaemonBatcher_Append_Call) RunAndReturn 

func (_c *ProducerDaemonBatcher_Append_Call) RunAndReturn(run func(*stream.Message) ([]stream.WritableMessage, error)) *ProducerDaemonBatcher_Append_Call

type ProducerDaemonBatcher_Expecter 

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

func (*ProducerDaemonBatcher_Expecter) Append 

func (_e *ProducerDaemonBatcher_Expecter) Append(msg interface{}) *ProducerDaemonBatcher_Append_Call

Append is a helper method to define mock.On call

  • msg *stream.Message

func (*ProducerDaemonBatcher_Expecter) Flush 

func (_e *ProducerDaemonBatcher_Expecter) Flush() *ProducerDaemonBatcher_Flush_Call

Flush is a helper method to define mock.On call

type ProducerDaemonBatcher_Flush_Call 

type ProducerDaemonBatcher_Flush_Call struct {
	*mock.Call
}

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

func (*ProducerDaemonBatcher_Flush_Call) Return 

func (_c *ProducerDaemonBatcher_Flush_Call) Return(_a0 []stream.WritableMessage) *ProducerDaemonBatcher_Flush_Call

func (*ProducerDaemonBatcher_Flush_Call) Run 

func (_c *ProducerDaemonBatcher_Flush_Call) Run(run func()) *ProducerDaemonBatcher_Flush_Call

func (*ProducerDaemonBatcher_Flush_Call) RunAndReturn 

func (_c *ProducerDaemonBatcher_Flush_Call) RunAndReturn(run func() []stream.WritableMessage) *ProducerDaemonBatcher_Flush_Call

type Producer_Expecter 

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

func (*Producer_Expecter) Write 

func (_e *Producer_Expecter) Write(ctx interface{}, models interface{}, attributeSets ...interface{}) *Producer_Write_Call

Write is a helper method to define mock.On call

  • ctx context.Context
  • models interface{}
  • attributeSets ...map[string]string

func (*Producer_Expecter) WriteOne 

func (_e *Producer_Expecter) WriteOne(ctx interface{}, model interface{}, attributeSets ...interface{}) *Producer_WriteOne_Call

WriteOne is a helper method to define mock.On call

  • ctx context.Context
  • model interface{}
  • attributeSets ...map[string]string

type Producer_WriteOne_Call 

type Producer_WriteOne_Call struct {
	*mock.Call
}

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

func (*Producer_WriteOne_Call) Return 

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

func (*Producer_WriteOne_Call) Run 

func (_c *Producer_WriteOne_Call) Run(run func(ctx context.Context, model interface{}, attributeSets ...map[string]string)) *Producer_WriteOne_Call

func (*Producer_WriteOne_Call) RunAndReturn 

func (_c *Producer_WriteOne_Call) RunAndReturn(run func(context.Context, interface{}, ...map[string]string) error) *Producer_WriteOne_Call

type Producer_Write_Call 

type Producer_Write_Call struct {
	*mock.Call
}

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

func (*Producer_Write_Call) Return 

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

func (*Producer_Write_Call) Run 

func (_c *Producer_Write_Call) Run(run func(ctx context.Context, models interface{}, attributeSets ...map[string]string)) *Producer_Write_Call

func (*Producer_Write_Call) RunAndReturn 

func (_c *Producer_Write_Call) RunAndReturn(run func(context.Context, interface{}, ...map[string]string) error) *Producer_Write_Call

type RetryHandler 

type RetryHandler struct {
	mock.Mock
}

RetryHandler is an autogenerated mock type for the RetryHandler type

func NewRetryHandler 

func NewRetryHandler(t interface {
	mock.TestingT
	Cleanup(func())
}) *RetryHandler

NewRetryHandler creates a new instance of RetryHandler. 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 (*RetryHandler) EXPECT 

func (_m *RetryHandler) EXPECT() *RetryHandler_Expecter

func (*RetryHandler) Put 

func (_m *RetryHandler) Put(ctx context.Context, msg *stream.Message) error

Put provides a mock function with given fields: ctx, msg

type RetryHandler_Expecter 

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

func (*RetryHandler_Expecter) Put 

func (_e *RetryHandler_Expecter) Put(ctx interface{}, msg interface{}) *RetryHandler_Put_Call

Put is a helper method to define mock.On call

  • ctx context.Context
  • msg *stream.Message

type RetryHandler_Put_Call 

type RetryHandler_Put_Call struct {
	*mock.Call
}

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

func (*RetryHandler_Put_Call) Return 

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

func (*RetryHandler_Put_Call) Run 

func (_c *RetryHandler_Put_Call) Run(run func(ctx context.Context, msg *stream.Message)) *RetryHandler_Put_Call

func (*RetryHandler_Put_Call) RunAndReturn 

func (_c *RetryHandler_Put_Call) RunAndReturn(run func(context.Context, *stream.Message) error) *RetryHandler_Put_Call

type RunnableBatchConsumerCallback 

type RunnableBatchConsumerCallback struct {
	mock.Mock
}

RunnableBatchConsumerCallback is an autogenerated mock type for the RunnableBatchConsumerCallback type

func NewRunnableBatchConsumerCallback 

func NewRunnableBatchConsumerCallback(t interface {
	mock.TestingT
	Cleanup(func())
}) *RunnableBatchConsumerCallback

NewRunnableBatchConsumerCallback creates a new instance of RunnableBatchConsumerCallback. 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 (*RunnableBatchConsumerCallback) Consume 

func (_m *RunnableBatchConsumerCallback) Consume(ctx context.Context, models []interface{}, attributes []map[string]string) ([]bool, error)

Consume provides a mock function with given fields: ctx, models, attributes

func (*RunnableBatchConsumerCallback) EXPECT 

func (_m *RunnableBatchConsumerCallback) EXPECT() *RunnableBatchConsumerCallback_Expecter

func (*RunnableBatchConsumerCallback) GetModel 

func (_m *RunnableBatchConsumerCallback) GetModel(attributes map[string]string) interface{}

GetModel provides a mock function with given fields: attributes

func (*RunnableBatchConsumerCallback) Run 

func (_m *RunnableBatchConsumerCallback) Run(ctx context.Context) error

Run provides a mock function with given fields: ctx

type RunnableBatchConsumerCallback_Consume_Call 

type RunnableBatchConsumerCallback_Consume_Call struct {
	*mock.Call
}

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

func (*RunnableBatchConsumerCallback_Consume_Call) Return 

func (_c *RunnableBatchConsumerCallback_Consume_Call) Return(_a0 []bool, _a1 error) *RunnableBatchConsumerCallback_Consume_Call

func (*RunnableBatchConsumerCallback_Consume_Call) Run 

func (_c *RunnableBatchConsumerCallback_Consume_Call) Run(run func(ctx context.Context, models []interface{}, attributes []map[string]string)) *RunnableBatchConsumerCallback_Consume_Call

func (*RunnableBatchConsumerCallback_Consume_Call) RunAndReturn 

func (_c *RunnableBatchConsumerCallback_Consume_Call) RunAndReturn(run func(context.Context, []interface{}, []map[string]string) ([]bool, error)) *RunnableBatchConsumerCallback_Consume_Call

type RunnableBatchConsumerCallback_Expecter 

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

func (*RunnableBatchConsumerCallback_Expecter) Consume 

func (_e *RunnableBatchConsumerCallback_Expecter) Consume(ctx interface{}, models interface{}, attributes interface{}) *RunnableBatchConsumerCallback_Consume_Call

Consume is a helper method to define mock.On call

  • ctx context.Context
  • models []interface{}
  • attributes []map[string]string

func (*RunnableBatchConsumerCallback_Expecter) GetModel 

func (_e *RunnableBatchConsumerCallback_Expecter) GetModel(attributes interface{}) *RunnableBatchConsumerCallback_GetModel_Call

GetModel is a helper method to define mock.On call

  • attributes map[string]string

func (*RunnableBatchConsumerCallback_Expecter) Run 

func (_e *RunnableBatchConsumerCallback_Expecter) Run(ctx interface{}) *RunnableBatchConsumerCallback_Run_Call

Run is a helper method to define mock.On call

  • ctx context.Context

type RunnableBatchConsumerCallback_GetModel_Call 

type RunnableBatchConsumerCallback_GetModel_Call struct {
	*mock.Call
}

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

func (*RunnableBatchConsumerCallback_GetModel_Call) Return 

func (_c *RunnableBatchConsumerCallback_GetModel_Call) Return(_a0 interface{}) *RunnableBatchConsumerCallback_GetModel_Call

func (*RunnableBatchConsumerCallback_GetModel_Call) Run 

func (_c *RunnableBatchConsumerCallback_GetModel_Call) Run(run func(attributes map[string]string)) *RunnableBatchConsumerCallback_GetModel_Call

func (*RunnableBatchConsumerCallback_GetModel_Call) RunAndReturn 

func (_c *RunnableBatchConsumerCallback_GetModel_Call) RunAndReturn(run func(map[string]string) interface{}) *RunnableBatchConsumerCallback_GetModel_Call

type RunnableBatchConsumerCallback_Run_Call 

type RunnableBatchConsumerCallback_Run_Call struct {
	*mock.Call
}

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

func (*RunnableBatchConsumerCallback_Run_Call) Return 

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

func (*RunnableBatchConsumerCallback_Run_Call) Run 

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

func (*RunnableBatchConsumerCallback_Run_Call) RunAndReturn 

func (_c *RunnableBatchConsumerCallback_Run_Call) RunAndReturn(run func(context.Context) error) *RunnableBatchConsumerCallback_Run_Call

type RunnableCallback 

type RunnableCallback struct {
	mock.Mock
}

RunnableCallback is an autogenerated mock type for the RunnableCallback type

func NewRunnableCallback 

func NewRunnableCallback(t interface {
	mock.TestingT
	Cleanup(func())
}) *RunnableCallback

NewRunnableCallback creates a new instance of RunnableCallback. 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 (*RunnableCallback) EXPECT 

func (_m *RunnableCallback) EXPECT() *RunnableCallback_Expecter

func (*RunnableCallback) Run 

func (_m *RunnableCallback) Run(ctx context.Context) error

Run provides a mock function with given fields: ctx

type RunnableCallback_Expecter 

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

func (*RunnableCallback_Expecter) Run 

func (_e *RunnableCallback_Expecter) Run(ctx interface{}) *RunnableCallback_Run_Call

Run is a helper method to define mock.On call

  • ctx context.Context

type RunnableCallback_Run_Call 

type RunnableCallback_Run_Call struct {
	*mock.Call
}

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

func (*RunnableCallback_Run_Call) Return 

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

func (*RunnableCallback_Run_Call) Run 

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

func (*RunnableCallback_Run_Call) RunAndReturn 

func (_c *RunnableCallback_Run_Call) RunAndReturn(run func(context.Context) error) *RunnableCallback_Run_Call

type RunnableConsumerCallback 

type RunnableConsumerCallback struct {
	mock.Mock
}

RunnableConsumerCallback is an autogenerated mock type for the RunnableConsumerCallback type

func NewRunnableConsumerCallback 

func NewRunnableConsumerCallback(t interface {
	mock.TestingT
	Cleanup(func())
}) *RunnableConsumerCallback

NewRunnableConsumerCallback creates a new instance of RunnableConsumerCallback. 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 (*RunnableConsumerCallback) Consume 

func (_m *RunnableConsumerCallback) Consume(ctx context.Context, model interface{}, attributes map[string]string) (bool, error)

Consume provides a mock function with given fields: ctx, model, attributes

func (*RunnableConsumerCallback) EXPECT 

func (_m *RunnableConsumerCallback) EXPECT() *RunnableConsumerCallback_Expecter

func (*RunnableConsumerCallback) GetModel 

func (_m *RunnableConsumerCallback) GetModel(attributes map[string]string) interface{}

GetModel provides a mock function with given fields: attributes

func (*RunnableConsumerCallback) Run 

func (_m *RunnableConsumerCallback) Run(ctx context.Context) error

Run provides a mock function with given fields: ctx

type RunnableConsumerCallback_Consume_Call 

type RunnableConsumerCallback_Consume_Call struct {
	*mock.Call
}

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

func (*RunnableConsumerCallback_Consume_Call) Return 

func (_c *RunnableConsumerCallback_Consume_Call) Return(_a0 bool, _a1 error) *RunnableConsumerCallback_Consume_Call

func (*RunnableConsumerCallback_Consume_Call) Run 

func (_c *RunnableConsumerCallback_Consume_Call) Run(run func(ctx context.Context, model interface{}, attributes map[string]string)) *RunnableConsumerCallback_Consume_Call

func (*RunnableConsumerCallback_Consume_Call) RunAndReturn 

func (_c *RunnableConsumerCallback_Consume_Call) RunAndReturn(run func(context.Context, interface{}, map[string]string) (bool, error)) *RunnableConsumerCallback_Consume_Call

type RunnableConsumerCallback_Expecter 

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

func (*RunnableConsumerCallback_Expecter) Consume 

func (_e *RunnableConsumerCallback_Expecter) Consume(ctx interface{}, model interface{}, attributes interface{}) *RunnableConsumerCallback_Consume_Call

Consume is a helper method to define mock.On call

  • ctx context.Context
  • model interface{}
  • attributes map[string]string

func (*RunnableConsumerCallback_Expecter) GetModel 

func (_e *RunnableConsumerCallback_Expecter) GetModel(attributes interface{}) *RunnableConsumerCallback_GetModel_Call

GetModel is a helper method to define mock.On call

  • attributes map[string]string

func (*RunnableConsumerCallback_Expecter) Run 

func (_e *RunnableConsumerCallback_Expecter) Run(ctx interface{}) *RunnableConsumerCallback_Run_Call

Run is a helper method to define mock.On call

  • ctx context.Context

type RunnableConsumerCallback_GetModel_Call 

type RunnableConsumerCallback_GetModel_Call struct {
	*mock.Call
}

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

func (*RunnableConsumerCallback_GetModel_Call) Return 

func (_c *RunnableConsumerCallback_GetModel_Call) Return(_a0 interface{}) *RunnableConsumerCallback_GetModel_Call

func (*RunnableConsumerCallback_GetModel_Call) Run 

func (_c *RunnableConsumerCallback_GetModel_Call) Run(run func(attributes map[string]string)) *RunnableConsumerCallback_GetModel_Call

func (*RunnableConsumerCallback_GetModel_Call) RunAndReturn 

func (_c *RunnableConsumerCallback_GetModel_Call) RunAndReturn(run func(map[string]string) interface{}) *RunnableConsumerCallback_GetModel_Call

type RunnableConsumerCallback_Run_Call 

type RunnableConsumerCallback_Run_Call struct {
	*mock.Call
}

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

func (*RunnableConsumerCallback_Run_Call) Return 

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

func (*RunnableConsumerCallback_Run_Call) Run 

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

func (*RunnableConsumerCallback_Run_Call) RunAndReturn 

func (_c *RunnableConsumerCallback_Run_Call) RunAndReturn(run func(context.Context) error) *RunnableConsumerCallback_Run_Call

type SizeRestrictedOutput 

type SizeRestrictedOutput struct {
	mock.Mock
}

SizeRestrictedOutput is an autogenerated mock type for the SizeRestrictedOutput type

func NewSizeRestrictedOutput 

func NewSizeRestrictedOutput(t interface {
	mock.TestingT
	Cleanup(func())
}) *SizeRestrictedOutput

NewSizeRestrictedOutput creates a new instance of SizeRestrictedOutput. 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 (*SizeRestrictedOutput) EXPECT 

func (_m *SizeRestrictedOutput) EXPECT() *SizeRestrictedOutput_Expecter

func (*SizeRestrictedOutput) GetMaxBatchSize 

func (_m *SizeRestrictedOutput) GetMaxBatchSize() *int

GetMaxBatchSize provides a mock function with given fields:

func (*SizeRestrictedOutput) GetMaxMessageSize 

func (_m *SizeRestrictedOutput) GetMaxMessageSize() *int

GetMaxMessageSize provides a mock function with given fields:

func (*SizeRestrictedOutput) Write 

func (_m *SizeRestrictedOutput) Write(ctx context.Context, batch []stream.WritableMessage) error

Write provides a mock function with given fields: ctx, batch

func (*SizeRestrictedOutput) WriteOne 

func (_m *SizeRestrictedOutput) WriteOne(ctx context.Context, msg stream.WritableMessage) error

WriteOne provides a mock function with given fields: ctx, msg

type SizeRestrictedOutput_Expecter 

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

func (*SizeRestrictedOutput_Expecter) GetMaxBatchSize 

func (_e *SizeRestrictedOutput_Expecter) GetMaxBatchSize() *SizeRestrictedOutput_GetMaxBatchSize_Call

GetMaxBatchSize is a helper method to define mock.On call

func (*SizeRestrictedOutput_Expecter) GetMaxMessageSize 

func (_e *SizeRestrictedOutput_Expecter) GetMaxMessageSize() *SizeRestrictedOutput_GetMaxMessageSize_Call

GetMaxMessageSize is a helper method to define mock.On call

func (*SizeRestrictedOutput_Expecter) Write 

func (_e *SizeRestrictedOutput_Expecter) Write(ctx interface{}, batch interface{}) *SizeRestrictedOutput_Write_Call

Write is a helper method to define mock.On call

  • ctx context.Context
  • batch []stream.WritableMessage

func (*SizeRestrictedOutput_Expecter) WriteOne 

func (_e *SizeRestrictedOutput_Expecter) WriteOne(ctx interface{}, msg interface{}) *SizeRestrictedOutput_WriteOne_Call

WriteOne is a helper method to define mock.On call

  • ctx context.Context
  • msg stream.WritableMessage

type SizeRestrictedOutput_GetMaxBatchSize_Call 

type SizeRestrictedOutput_GetMaxBatchSize_Call struct {
	*mock.Call
}

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

func (*SizeRestrictedOutput_GetMaxBatchSize_Call) Return 

func (_c *SizeRestrictedOutput_GetMaxBatchSize_Call) Return(_a0 *int) *SizeRestrictedOutput_GetMaxBatchSize_Call

func (*SizeRestrictedOutput_GetMaxBatchSize_Call) Run 

func (_c *SizeRestrictedOutput_GetMaxBatchSize_Call) Run(run func()) *SizeRestrictedOutput_GetMaxBatchSize_Call

func (*SizeRestrictedOutput_GetMaxBatchSize_Call) RunAndReturn 

func (_c *SizeRestrictedOutput_GetMaxBatchSize_Call) RunAndReturn(run func() *int) *SizeRestrictedOutput_GetMaxBatchSize_Call

type SizeRestrictedOutput_GetMaxMessageSize_Call 

type SizeRestrictedOutput_GetMaxMessageSize_Call struct {
	*mock.Call
}

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

func (*SizeRestrictedOutput_GetMaxMessageSize_Call) Return 

func (_c *SizeRestrictedOutput_GetMaxMessageSize_Call) Return(_a0 *int) *SizeRestrictedOutput_GetMaxMessageSize_Call

func (*SizeRestrictedOutput_GetMaxMessageSize_Call) Run 

func (_c *SizeRestrictedOutput_GetMaxMessageSize_Call) Run(run func()) *SizeRestrictedOutput_GetMaxMessageSize_Call

func (*SizeRestrictedOutput_GetMaxMessageSize_Call) RunAndReturn 

func (_c *SizeRestrictedOutput_GetMaxMessageSize_Call) RunAndReturn(run func() *int) *SizeRestrictedOutput_GetMaxMessageSize_Call

type SizeRestrictedOutput_WriteOne_Call 

type SizeRestrictedOutput_WriteOne_Call struct {
	*mock.Call
}

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

func (*SizeRestrictedOutput_WriteOne_Call) Return 

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

func (*SizeRestrictedOutput_WriteOne_Call) Run 

func (_c *SizeRestrictedOutput_WriteOne_Call) Run(run func(ctx context.Context, msg stream.WritableMessage)) *SizeRestrictedOutput_WriteOne_Call

func (*SizeRestrictedOutput_WriteOne_Call) RunAndReturn 

func (_c *SizeRestrictedOutput_WriteOne_Call) RunAndReturn(run func(context.Context, stream.WritableMessage) error) *SizeRestrictedOutput_WriteOne_Call

type SizeRestrictedOutput_Write_Call 

type SizeRestrictedOutput_Write_Call struct {
	*mock.Call
}

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

func (*SizeRestrictedOutput_Write_Call) Return 

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

func (*SizeRestrictedOutput_Write_Call) Run 

func (_c *SizeRestrictedOutput_Write_Call) Run(run func(ctx context.Context, batch []stream.WritableMessage)) *SizeRestrictedOutput_Write_Call

func (*SizeRestrictedOutput_Write_Call) RunAndReturn 

func (_c *SizeRestrictedOutput_Write_Call) RunAndReturn(run func(context.Context, []stream.WritableMessage) error) *SizeRestrictedOutput_Write_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.