mock_source_test.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/conduitio/conduit-connector-sdk (interfaces: Source)
//
// Generated by this command:
//
//	mockgen -typed -destination=mock_source_test.go -self_package=github.com/conduitio/conduit-connector-sdk -package=sdk -write_package_comment=false . Source
//

package sdk

import (
	context "context"
	reflect "reflect"

	config "github.com/conduitio/conduit-commons/config"
	opencdc "github.com/conduitio/conduit-commons/opencdc"
	gomock "go.uber.org/mock/gomock"
)

// MockSource is a mock of Source interface.
type MockSource struct {
	ctrl     *gomock.Controller
	recorder *MockSourceMockRecorder
	isgomock struct{}
}

// MockSourceMockRecorder is the mock recorder for MockSource.
type MockSourceMockRecorder struct {
	mock *MockSource
}

// NewMockSource creates a new mock instance.
func NewMockSource(ctrl *gomock.Controller) *MockSource {
	mock := &MockSource{ctrl: ctrl}
	mock.recorder = &MockSourceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSource) EXPECT() *MockSourceMockRecorder {
	return m.recorder
}

// Ack mocks base method.
func (m *MockSource) Ack(arg0 context.Context, arg1 opencdc.Position) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Ack", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Ack indicates an expected call of Ack.
func (mr *MockSourceMockRecorder) Ack(arg0, arg1 any) *MockSourceAckCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ack", reflect.TypeOf((*MockSource)(nil).Ack), arg0, arg1)
	return &MockSourceAckCall{Call: call}
}

// MockSourceAckCall wrap *gomock.Call
type MockSourceAckCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSourceAckCall) Return(arg0 error) *MockSourceAckCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSourceAckCall) Do(f func(context.Context, opencdc.Position) error) *MockSourceAckCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSourceAckCall) DoAndReturn(f func(context.Context, opencdc.Position) error) *MockSourceAckCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Configure mocks base method.
func (m *MockSource) Configure(arg0 context.Context, arg1 config.Config) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Configure", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Configure indicates an expected call of Configure.
func (mr *MockSourceMockRecorder) Configure(arg0, arg1 any) *MockSourceConfigureCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Configure", reflect.TypeOf((*MockSource)(nil).Configure), arg0, arg1)
	return &MockSourceConfigureCall{Call: call}
}

// MockSourceConfigureCall wrap *gomock.Call
type MockSourceConfigureCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSourceConfigureCall) Return(arg0 error) *MockSourceConfigureCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSourceConfigureCall) Do(f func(context.Context, config.Config) error) *MockSourceConfigureCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSourceConfigureCall) DoAndReturn(f func(context.Context, config.Config) error) *MockSourceConfigureCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LifecycleOnCreated mocks base method.
func (m *MockSource) LifecycleOnCreated(ctx context.Context, config config.Config) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LifecycleOnCreated", ctx, config)
	ret0, _ := ret[0].(error)
	return ret0
}

// LifecycleOnCreated indicates an expected call of LifecycleOnCreated.
func (mr *MockSourceMockRecorder) LifecycleOnCreated(ctx, config any) *MockSourceLifecycleOnCreatedCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LifecycleOnCreated", reflect.TypeOf((*MockSource)(nil).LifecycleOnCreated), ctx, config)
	return &MockSourceLifecycleOnCreatedCall{Call: call}
}

// MockSourceLifecycleOnCreatedCall wrap *gomock.Call
type MockSourceLifecycleOnCreatedCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSourceLifecycleOnCreatedCall) Return(arg0 error) *MockSourceLifecycleOnCreatedCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSourceLifecycleOnCreatedCall) Do(f func(context.Context, config.Config) error) *MockSourceLifecycleOnCreatedCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSourceLifecycleOnCreatedCall) DoAndReturn(f func(context.Context, config.Config) error) *MockSourceLifecycleOnCreatedCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LifecycleOnDeleted mocks base method.
func (m *MockSource) LifecycleOnDeleted(ctx context.Context, config config.Config) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LifecycleOnDeleted", ctx, config)
	ret0, _ := ret[0].(error)
	return ret0
}

// LifecycleOnDeleted indicates an expected call of LifecycleOnDeleted.
func (mr *MockSourceMockRecorder) LifecycleOnDeleted(ctx, config any) *MockSourceLifecycleOnDeletedCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LifecycleOnDeleted", reflect.TypeOf((*MockSource)(nil).LifecycleOnDeleted), ctx, config)
	return &MockSourceLifecycleOnDeletedCall{Call: call}
}

// MockSourceLifecycleOnDeletedCall wrap *gomock.Call
type MockSourceLifecycleOnDeletedCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSourceLifecycleOnDeletedCall) Return(arg0 error) *MockSourceLifecycleOnDeletedCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSourceLifecycleOnDeletedCall) Do(f func(context.Context, config.Config) error) *MockSourceLifecycleOnDeletedCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSourceLifecycleOnDeletedCall) DoAndReturn(f func(context.Context, config.Config) error) *MockSourceLifecycleOnDeletedCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LifecycleOnUpdated mocks base method.
func (m *MockSource) LifecycleOnUpdated(ctx context.Context, configBefore, configAfter config.Config) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LifecycleOnUpdated", ctx, configBefore, configAfter)
	ret0, _ := ret[0].(error)
	return ret0
}

// LifecycleOnUpdated indicates an expected call of LifecycleOnUpdated.
func (mr *MockSourceMockRecorder) LifecycleOnUpdated(ctx, configBefore, configAfter any) *MockSourceLifecycleOnUpdatedCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LifecycleOnUpdated", reflect.TypeOf((*MockSource)(nil).LifecycleOnUpdated), ctx, configBefore, configAfter)
	return &MockSourceLifecycleOnUpdatedCall{Call: call}
}

// MockSourceLifecycleOnUpdatedCall wrap *gomock.Call
type MockSourceLifecycleOnUpdatedCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSourceLifecycleOnUpdatedCall) Return(arg0 error) *MockSourceLifecycleOnUpdatedCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSourceLifecycleOnUpdatedCall) Do(f func(context.Context, config.Config, config.Config) error) *MockSourceLifecycleOnUpdatedCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSourceLifecycleOnUpdatedCall) DoAndReturn(f func(context.Context, config.Config, config.Config) error) *MockSourceLifecycleOnUpdatedCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Open mocks base method.
func (m *MockSource) Open(arg0 context.Context, arg1 opencdc.Position) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Open", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Open indicates an expected call of Open.
func (mr *MockSourceMockRecorder) Open(arg0, arg1 any) *MockSourceOpenCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockSource)(nil).Open), arg0, arg1)
	return &MockSourceOpenCall{Call: call}
}

// MockSourceOpenCall wrap *gomock.Call
type MockSourceOpenCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSourceOpenCall) Return(arg0 error) *MockSourceOpenCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSourceOpenCall) Do(f func(context.Context, opencdc.Position) error) *MockSourceOpenCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSourceOpenCall) DoAndReturn(f func(context.Context, opencdc.Position) error) *MockSourceOpenCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Parameters mocks base method.
func (m *MockSource) Parameters() config.Parameters {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Parameters")
	ret0, _ := ret[0].(config.Parameters)
	return ret0
}

// Parameters indicates an expected call of Parameters.
func (mr *MockSourceMockRecorder) Parameters() *MockSourceParametersCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Parameters", reflect.TypeOf((*MockSource)(nil).Parameters))
	return &MockSourceParametersCall{Call: call}
}

// MockSourceParametersCall wrap *gomock.Call
type MockSourceParametersCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSourceParametersCall) Return(arg0 config.Parameters) *MockSourceParametersCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSourceParametersCall) Do(f func() config.Parameters) *MockSourceParametersCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSourceParametersCall) DoAndReturn(f func() config.Parameters) *MockSourceParametersCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Read mocks base method.
func (m *MockSource) Read(arg0 context.Context) (opencdc.Record, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", arg0)
	ret0, _ := ret[0].(opencdc.Record)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockSourceMockRecorder) Read(arg0 any) *MockSourceReadCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockSource)(nil).Read), arg0)
	return &MockSourceReadCall{Call: call}
}

// MockSourceReadCall wrap *gomock.Call
type MockSourceReadCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSourceReadCall) Return(arg0 opencdc.Record, arg1 error) *MockSourceReadCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSourceReadCall) Do(f func(context.Context) (opencdc.Record, error)) *MockSourceReadCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSourceReadCall) DoAndReturn(f func(context.Context) (opencdc.Record, error)) *MockSourceReadCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ReadN mocks base method.
func (m *MockSource) ReadN(arg0 context.Context, arg1 int) ([]opencdc.Record, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadN", arg0, arg1)
	ret0, _ := ret[0].([]opencdc.Record)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadN indicates an expected call of ReadN.
func (mr *MockSourceMockRecorder) ReadN(arg0, arg1 any) *MockSourceReadNCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadN", reflect.TypeOf((*MockSource)(nil).ReadN), arg0, arg1)
	return &MockSourceReadNCall{Call: call}
}

// MockSourceReadNCall wrap *gomock.Call
type MockSourceReadNCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSourceReadNCall) Return(arg0 []opencdc.Record, arg1 error) *MockSourceReadNCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSourceReadNCall) Do(f func(context.Context, int) ([]opencdc.Record, error)) *MockSourceReadNCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSourceReadNCall) DoAndReturn(f func(context.Context, int) ([]opencdc.Record, error)) *MockSourceReadNCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Teardown mocks base method.
func (m *MockSource) Teardown(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Teardown", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Teardown indicates an expected call of Teardown.
func (mr *MockSourceMockRecorder) Teardown(arg0 any) *MockSourceTeardownCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Teardown", reflect.TypeOf((*MockSource)(nil).Teardown), arg0)
	return &MockSourceTeardownCall{Call: call}
}

// MockSourceTeardownCall wrap *gomock.Call
type MockSourceTeardownCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSourceTeardownCall) Return(arg0 error) *MockSourceTeardownCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSourceTeardownCall) Do(f func(context.Context) error) *MockSourceTeardownCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSourceTeardownCall) DoAndReturn(f func(context.Context) error) *MockSourceTeardownCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// mustEmbedUnimplementedSource mocks base method.
func (m *MockSource) mustEmbedUnimplementedSource() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "mustEmbedUnimplementedSource")
}

// mustEmbedUnimplementedSource indicates an expected call of mustEmbedUnimplementedSource.
func (mr *MockSourceMockRecorder) mustEmbedUnimplementedSource() *MockSourcemustEmbedUnimplementedSourceCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedSource", reflect.TypeOf((*MockSource)(nil).mustEmbedUnimplementedSource))
	return &MockSourcemustEmbedUnimplementedSourceCall{Call: call}
}

// MockSourcemustEmbedUnimplementedSourceCall wrap *gomock.Call
type MockSourcemustEmbedUnimplementedSourceCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSourcemustEmbedUnimplementedSourceCall) Return() *MockSourcemustEmbedUnimplementedSourceCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSourcemustEmbedUnimplementedSourceCall) Do(f func()) *MockSourcemustEmbedUnimplementedSourceCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSourcemustEmbedUnimplementedSourceCall) DoAndReturn(f func()) *MockSourcemustEmbedUnimplementedSourceCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}