mock_destination_test.go

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

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"
)

// MockDestination is a mock of Destination interface.
type MockDestination struct {
	ctrl     *gomock.Controller
	recorder *MockDestinationMockRecorder
	isgomock struct{}
}

// MockDestinationMockRecorder is the mock recorder for MockDestination.
type MockDestinationMockRecorder struct {
	mock *MockDestination
}

// NewMockDestination creates a new mock instance.
func NewMockDestination(ctrl *gomock.Controller) *MockDestination {
	mock := &MockDestination{ctrl: ctrl}
	mock.recorder = &MockDestinationMockRecorder{mock}
	return mock
}

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

// Configure mocks base method.
func (m *MockDestination) 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 *MockDestinationMockRecorder) Configure(arg0, arg1 any) *MockDestinationConfigureCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Configure", reflect.TypeOf((*MockDestination)(nil).Configure), arg0, arg1)
	return &MockDestinationConfigureCall{Call: call}
}

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

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

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

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

// LifecycleOnCreated mocks base method.
func (m *MockDestination) 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 *MockDestinationMockRecorder) LifecycleOnCreated(ctx, config any) *MockDestinationLifecycleOnCreatedCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LifecycleOnCreated", reflect.TypeOf((*MockDestination)(nil).LifecycleOnCreated), ctx, config)
	return &MockDestinationLifecycleOnCreatedCall{Call: call}
}

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

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

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

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

// LifecycleOnDeleted mocks base method.
func (m *MockDestination) 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 *MockDestinationMockRecorder) LifecycleOnDeleted(ctx, config any) *MockDestinationLifecycleOnDeletedCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LifecycleOnDeleted", reflect.TypeOf((*MockDestination)(nil).LifecycleOnDeleted), ctx, config)
	return &MockDestinationLifecycleOnDeletedCall{Call: call}
}

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

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

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

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

// LifecycleOnUpdated mocks base method.
func (m *MockDestination) 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 *MockDestinationMockRecorder) LifecycleOnUpdated(ctx, configBefore, configAfter any) *MockDestinationLifecycleOnUpdatedCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LifecycleOnUpdated", reflect.TypeOf((*MockDestination)(nil).LifecycleOnUpdated), ctx, configBefore, configAfter)
	return &MockDestinationLifecycleOnUpdatedCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

// Parameters mocks base method.
func (m *MockDestination) 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 *MockDestinationMockRecorder) Parameters() *MockDestinationParametersCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Parameters", reflect.TypeOf((*MockDestination)(nil).Parameters))
	return &MockDestinationParametersCall{Call: call}
}

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

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

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

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

// Teardown mocks base method.
func (m *MockDestination) 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 *MockDestinationMockRecorder) Teardown(arg0 any) *MockDestinationTeardownCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Teardown", reflect.TypeOf((*MockDestination)(nil).Teardown), arg0)
	return &MockDestinationTeardownCall{Call: call}
}

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

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

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

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

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

// Write indicates an expected call of Write.
func (mr *MockDestinationMockRecorder) Write(ctx, r any) *MockDestinationWriteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockDestination)(nil).Write), ctx, r)
	return &MockDestinationWriteCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockDestinationWriteCall) Return(n int, err error) *MockDestinationWriteCall {
	c.Call = c.Call.Return(n, err)
	return c
}

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

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

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

// mustEmbedUnimplementedDestination indicates an expected call of mustEmbedUnimplementedDestination.
func (mr *MockDestinationMockRecorder) mustEmbedUnimplementedDestination() *MockDestinationmustEmbedUnimplementedDestinationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedDestination", reflect.TypeOf((*MockDestination)(nil).mustEmbedUnimplementedDestination))
	return &MockDestinationmustEmbedUnimplementedDestinationCall{Call: call}
}

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

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

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

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