mocks

Oct 12, 2023

Changes in this version

+ type Batcher struct

+ func NewBatcher(t mockConstructorTestingTNewBatcher) *Batcher

+ func (_m *Batcher) EXPECT() *Batcher_Expecter

+ func (_m *Batcher) Get(ctx context.Context) []kafka.Message

+ type Batcher_Expecter struct

+ func (_e *Batcher_Expecter) Get(ctx interface{}) *Batcher_Get_Call

+ type Batcher_Get_Call struct

+ func (_c *Batcher_Get_Call) Return(_a0 []kafka.Message) *Batcher_Get_Call

+ func (_c *Batcher_Get_Call) Run(run func(ctx context.Context)) *Batcher_Get_Call

+ func (_c *Batcher_Get_Call) RunAndReturn(run func(context.Context) []kafka.Message) *Batcher_Get_Call

+ type OffsetManager struct

+ func NewOffsetManager(t mockConstructorTestingTNewOffsetManager) *OffsetManager

+ func (_m *OffsetManager) Batch(ctx context.Context) []kafka.Message

+ func (_m *OffsetManager) Commit(ctx context.Context, msgs ...kafka.Message) error

+ func (_m *OffsetManager) EXPECT() *OffsetManager_Expecter

+ func (_m *OffsetManager) Flush() error

+ func (_m *OffsetManager) Start(ctx context.Context) error

+ type OffsetManager_Batch_Call struct

+ func (_c *OffsetManager_Batch_Call) Return(_a0 []kafka.Message) *OffsetManager_Batch_Call

+ func (_c *OffsetManager_Batch_Call) Run(run func(ctx context.Context)) *OffsetManager_Batch_Call

+ func (_c *OffsetManager_Batch_Call) RunAndReturn(run func(context.Context) []kafka.Message) *OffsetManager_Batch_Call

+ type OffsetManager_Commit_Call struct

+ func (_c *OffsetManager_Commit_Call) Return(_a0 error) *OffsetManager_Commit_Call

+ func (_c *OffsetManager_Commit_Call) Run(run func(ctx context.Context, msgs ...kafka.Message)) *OffsetManager_Commit_Call

+ func (_c *OffsetManager_Commit_Call) RunAndReturn(run func(context.Context, ...kafka.Message) error) *OffsetManager_Commit_Call

+ type OffsetManager_Expecter struct

+ func (_e *OffsetManager_Expecter) Batch(ctx interface{}) *OffsetManager_Batch_Call

+ func (_e *OffsetManager_Expecter) Commit(ctx interface{}, msgs ...interface{}) *OffsetManager_Commit_Call

+ func (_e *OffsetManager_Expecter) Flush() *OffsetManager_Flush_Call

+ func (_e *OffsetManager_Expecter) Start(ctx interface{}) *OffsetManager_Start_Call

+ type OffsetManager_Flush_Call struct

+ func (_c *OffsetManager_Flush_Call) Return(_a0 error) *OffsetManager_Flush_Call

+ func (_c *OffsetManager_Flush_Call) Run(run func()) *OffsetManager_Flush_Call

+ func (_c *OffsetManager_Flush_Call) RunAndReturn(run func() error) *OffsetManager_Flush_Call

+ type OffsetManager_Start_Call struct

+ func (_c *OffsetManager_Start_Call) Return(_a0 error) *OffsetManager_Start_Call

+ func (_c *OffsetManager_Start_Call) Run(run func(ctx context.Context)) *OffsetManager_Start_Call

+ func (_c *OffsetManager_Start_Call) RunAndReturn(run func(context.Context) error) *OffsetManager_Start_Call

+ type Reader struct

+ func NewReader(t mockConstructorTestingTNewReader) *Reader

+ func (_m *Reader) Close() error

+ func (_m *Reader) CommitMessages(_a0 context.Context, _a1 ...kafka.Message) error

+ func (_m *Reader) EXPECT() *Reader_Expecter

+ func (_m *Reader) FetchMessage(_a0 context.Context) (kafka.Message, error)

+ func (_m *Reader) ReadMessage(_a0 context.Context) (kafka.Message, error)

+ func (_m *Reader) Stats() kafka.ReaderStats

+ type Reader_Close_Call struct

+ func (_c *Reader_Close_Call) Return(_a0 error) *Reader_Close_Call

+ func (_c *Reader_Close_Call) Run(run func()) *Reader_Close_Call

+ func (_c *Reader_Close_Call) RunAndReturn(run func() error) *Reader_Close_Call

+ type Reader_CommitMessages_Call struct

+ func (_c *Reader_CommitMessages_Call) Return(_a0 error) *Reader_CommitMessages_Call

+ func (_c *Reader_CommitMessages_Call) Run(run func(_a0 context.Context, _a1 ...kafka.Message)) *Reader_CommitMessages_Call

+ func (_c *Reader_CommitMessages_Call) RunAndReturn(run func(context.Context, ...kafka.Message) error) *Reader_CommitMessages_Call

+ type Reader_Expecter struct

+ func (_e *Reader_Expecter) Close() *Reader_Close_Call

+ func (_e *Reader_Expecter) CommitMessages(_a0 interface{}, _a1 ...interface{}) *Reader_CommitMessages_Call

+ func (_e *Reader_Expecter) FetchMessage(_a0 interface{}) *Reader_FetchMessage_Call

+ func (_e *Reader_Expecter) ReadMessage(_a0 interface{}) *Reader_ReadMessage_Call

+ func (_e *Reader_Expecter) Stats() *Reader_Stats_Call

+ type Reader_FetchMessage_Call struct

+ func (_c *Reader_FetchMessage_Call) Return(_a0 kafka.Message, _a1 error) *Reader_FetchMessage_Call

+ func (_c *Reader_FetchMessage_Call) Run(run func(_a0 context.Context)) *Reader_FetchMessage_Call

+ func (_c *Reader_FetchMessage_Call) RunAndReturn(run func(context.Context) (kafka.Message, error)) *Reader_FetchMessage_Call

+ type Reader_ReadMessage_Call struct

+ func (_c *Reader_ReadMessage_Call) Return(_a0 kafka.Message, _a1 error) *Reader_ReadMessage_Call

+ func (_c *Reader_ReadMessage_Call) Run(run func(_a0 context.Context)) *Reader_ReadMessage_Call

+ func (_c *Reader_ReadMessage_Call) RunAndReturn(run func(context.Context) (kafka.Message, error)) *Reader_ReadMessage_Call

+ type Reader_Stats_Call struct

+ func (_c *Reader_Stats_Call) Return(_a0 kafka.ReaderStats) *Reader_Stats_Call

+ func (_c *Reader_Stats_Call) Run(run func()) *Reader_Stats_Call

+ func (_c *Reader_Stats_Call) RunAndReturn(run func() kafka.ReaderStats) *Reader_Stats_Call