dbinterface_test.go

// Code generated by mockery. DO NOT EDIT.

package queue

import (
	context "context"

	mock "github.com/stretchr/testify/mock"
	mongo "go.mongodb.org/mongo-driver/mongo"

	options "go.mongodb.org/mongo-driver/mongo/options"

	primitive "go.mongodb.org/mongo-driver/bson/primitive"
)

// DbInterfaceMock is an autogenerated mock type for the DbInterface type
type DbInterfaceMock struct {
	mock.Mock
}

type DbInterfaceMock_Expecter struct {
	mock *mock.Mock
}

func (_m *DbInterfaceMock) EXPECT() *DbInterfaceMock_Expecter {
	return &DbInterfaceMock_Expecter{mock: &_m.Mock}
}

// Context provides a mock function with given fields:
func (_m *DbInterfaceMock) Context() context.Context {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Context")
	}

	var r0 context.Context
	if rf, ok := ret.Get(0).(func() context.Context); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(context.Context)
		}
	}

	return r0
}

// DbInterfaceMock_Context_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Context'
type DbInterfaceMock_Context_Call struct {
	*mock.Call
}

// Context is a helper method to define mock.On call
func (_e *DbInterfaceMock_Expecter) Context() *DbInterfaceMock_Context_Call {
	return &DbInterfaceMock_Context_Call{Call: _e.mock.On("Context")}
}

func (_c *DbInterfaceMock_Context_Call) Run(run func()) *DbInterfaceMock_Context_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *DbInterfaceMock_Context_Call) Return(_a0 context.Context) *DbInterfaceMock_Context_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DbInterfaceMock_Context_Call) RunAndReturn(run func() context.Context) *DbInterfaceMock_Context_Call {
	_c.Call.Return(run)
	return _c
}

// CreateIndexes provides a mock function with given fields: index
func (_m *DbInterfaceMock) CreateIndexes(index []mongo.IndexModel) error {
	ret := _m.Called(index)

	if len(ret) == 0 {
		panic("no return value specified for CreateIndexes")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func([]mongo.IndexModel) error); ok {
		r0 = rf(index)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DbInterfaceMock_CreateIndexes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIndexes'
type DbInterfaceMock_CreateIndexes_Call struct {
	*mock.Call
}

// CreateIndexes is a helper method to define mock.On call
//   - index []mongo.IndexModel
func (_e *DbInterfaceMock_Expecter) CreateIndexes(index interface{}) *DbInterfaceMock_CreateIndexes_Call {
	return &DbInterfaceMock_CreateIndexes_Call{Call: _e.mock.On("CreateIndexes", index)}
}

func (_c *DbInterfaceMock_CreateIndexes_Call) Run(run func(index []mongo.IndexModel)) *DbInterfaceMock_CreateIndexes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]mongo.IndexModel))
	})
	return _c
}

func (_c *DbInterfaceMock_CreateIndexes_Call) Return(_a0 error) *DbInterfaceMock_CreateIndexes_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DbInterfaceMock_CreateIndexes_Call) RunAndReturn(run func([]mongo.IndexModel) error) *DbInterfaceMock_CreateIndexes_Call {
	_c.Call.Return(run)
	return _c
}

// FindOneAndUpdate provides a mock function with given fields: filter, update, opts
func (_m *DbInterfaceMock) FindOneAndUpdate(filter interface{}, update interface{}, opts ...*options.FindOneAndUpdateOptions) *mongo.SingleResult {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, filter, update)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for FindOneAndUpdate")
	}

	var r0 *mongo.SingleResult
	if rf, ok := ret.Get(0).(func(interface{}, interface{}, ...*options.FindOneAndUpdateOptions) *mongo.SingleResult); ok {
		r0 = rf(filter, update, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*mongo.SingleResult)
		}
	}

	return r0
}

// DbInterfaceMock_FindOneAndUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindOneAndUpdate'
type DbInterfaceMock_FindOneAndUpdate_Call struct {
	*mock.Call
}

// FindOneAndUpdate is a helper method to define mock.On call
//   - filter interface{}
//   - update interface{}
//   - opts ...*options.FindOneAndUpdateOptions
func (_e *DbInterfaceMock_Expecter) FindOneAndUpdate(filter interface{}, update interface{}, opts ...interface{}) *DbInterfaceMock_FindOneAndUpdate_Call {
	return &DbInterfaceMock_FindOneAndUpdate_Call{Call: _e.mock.On("FindOneAndUpdate",
		append([]interface{}{filter, update}, opts...)...)}
}

func (_c *DbInterfaceMock_FindOneAndUpdate_Call) Run(run func(filter interface{}, update interface{}, opts ...*options.FindOneAndUpdateOptions)) *DbInterfaceMock_FindOneAndUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]*options.FindOneAndUpdateOptions, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(*options.FindOneAndUpdateOptions)
			}
		}
		run(args[0].(interface{}), args[1].(interface{}), variadicArgs...)
	})
	return _c
}

func (_c *DbInterfaceMock_FindOneAndUpdate_Call) Return(_a0 *mongo.SingleResult) *DbInterfaceMock_FindOneAndUpdate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DbInterfaceMock_FindOneAndUpdate_Call) RunAndReturn(run func(interface{}, interface{}, ...*options.FindOneAndUpdateOptions) *mongo.SingleResult) *DbInterfaceMock_FindOneAndUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// InsertOne provides a mock function with given fields: document
func (_m *DbInterfaceMock) InsertOne(document interface{}) (primitive.ObjectID, error) {
	ret := _m.Called(document)

	if len(ret) == 0 {
		panic("no return value specified for InsertOne")
	}

	var r0 primitive.ObjectID
	var r1 error
	if rf, ok := ret.Get(0).(func(interface{}) (primitive.ObjectID, error)); ok {
		return rf(document)
	}
	if rf, ok := ret.Get(0).(func(interface{}) primitive.ObjectID); ok {
		r0 = rf(document)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(primitive.ObjectID)
		}
	}

	if rf, ok := ret.Get(1).(func(interface{}) error); ok {
		r1 = rf(document)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DbInterfaceMock_InsertOne_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertOne'
type DbInterfaceMock_InsertOne_Call struct {
	*mock.Call
}

// InsertOne is a helper method to define mock.On call
//   - document interface{}
func (_e *DbInterfaceMock_Expecter) InsertOne(document interface{}) *DbInterfaceMock_InsertOne_Call {
	return &DbInterfaceMock_InsertOne_Call{Call: _e.mock.On("InsertOne", document)}
}

func (_c *DbInterfaceMock_InsertOne_Call) Run(run func(document interface{})) *DbInterfaceMock_InsertOne_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(interface{}))
	})
	return _c
}

func (_c *DbInterfaceMock_InsertOne_Call) Return(_a0 primitive.ObjectID, _a1 error) *DbInterfaceMock_InsertOne_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DbInterfaceMock_InsertOne_Call) RunAndReturn(run func(interface{}) (primitive.ObjectID, error)) *DbInterfaceMock_InsertOne_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateMany provides a mock function with given fields: filter, update
func (_m *DbInterfaceMock) UpdateMany(filter interface{}, update interface{}) error {
	ret := _m.Called(filter, update)

	if len(ret) == 0 {
		panic("no return value specified for UpdateMany")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(interface{}, interface{}) error); ok {
		r0 = rf(filter, update)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DbInterfaceMock_UpdateMany_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateMany'
type DbInterfaceMock_UpdateMany_Call struct {
	*mock.Call
}

// UpdateMany is a helper method to define mock.On call
//   - filter interface{}
//   - update interface{}
func (_e *DbInterfaceMock_Expecter) UpdateMany(filter interface{}, update interface{}) *DbInterfaceMock_UpdateMany_Call {
	return &DbInterfaceMock_UpdateMany_Call{Call: _e.mock.On("UpdateMany", filter, update)}
}

func (_c *DbInterfaceMock_UpdateMany_Call) Run(run func(filter interface{}, update interface{})) *DbInterfaceMock_UpdateMany_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(interface{}), args[1].(interface{}))
	})
	return _c
}

func (_c *DbInterfaceMock_UpdateMany_Call) Return(_a0 error) *DbInterfaceMock_UpdateMany_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DbInterfaceMock_UpdateMany_Call) RunAndReturn(run func(interface{}, interface{}) error) *DbInterfaceMock_UpdateMany_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateOne provides a mock function with given fields: filter, update
func (_m *DbInterfaceMock) UpdateOne(filter interface{}, update interface{}) error {
	ret := _m.Called(filter, update)

	if len(ret) == 0 {
		panic("no return value specified for UpdateOne")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(interface{}, interface{}) error); ok {
		r0 = rf(filter, update)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DbInterfaceMock_UpdateOne_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOne'
type DbInterfaceMock_UpdateOne_Call struct {
	*mock.Call
}

// UpdateOne is a helper method to define mock.On call
//   - filter interface{}
//   - update interface{}
func (_e *DbInterfaceMock_Expecter) UpdateOne(filter interface{}, update interface{}) *DbInterfaceMock_UpdateOne_Call {
	return &DbInterfaceMock_UpdateOne_Call{Call: _e.mock.On("UpdateOne", filter, update)}
}

func (_c *DbInterfaceMock_UpdateOne_Call) Run(run func(filter interface{}, update interface{})) *DbInterfaceMock_UpdateOne_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(interface{}), args[1].(interface{}))
	})
	return _c
}

func (_c *DbInterfaceMock_UpdateOne_Call) Return(_a0 error) *DbInterfaceMock_UpdateOne_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DbInterfaceMock_UpdateOne_Call) RunAndReturn(run func(interface{}, interface{}) error) *DbInterfaceMock_UpdateOne_Call {
	_c.Call.Return(run)
	return _c
}

// Watch provides a mock function with given fields: pipeline
func (_m *DbInterfaceMock) Watch(pipeline interface{}) (ChangeStreamInterface, error) {
	ret := _m.Called(pipeline)

	if len(ret) == 0 {
		panic("no return value specified for Watch")
	}

	var r0 ChangeStreamInterface
	var r1 error
	if rf, ok := ret.Get(0).(func(interface{}) (ChangeStreamInterface, error)); ok {
		return rf(pipeline)
	}
	if rf, ok := ret.Get(0).(func(interface{}) ChangeStreamInterface); ok {
		r0 = rf(pipeline)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ChangeStreamInterface)
		}
	}

	if rf, ok := ret.Get(1).(func(interface{}) error); ok {
		r1 = rf(pipeline)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DbInterfaceMock_Watch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Watch'
type DbInterfaceMock_Watch_Call struct {
	*mock.Call
}

// Watch is a helper method to define mock.On call
//   - pipeline interface{}
func (_e *DbInterfaceMock_Expecter) Watch(pipeline interface{}) *DbInterfaceMock_Watch_Call {
	return &DbInterfaceMock_Watch_Call{Call: _e.mock.On("Watch", pipeline)}
}

func (_c *DbInterfaceMock_Watch_Call) Run(run func(pipeline interface{})) *DbInterfaceMock_Watch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(interface{}))
	})
	return _c
}

func (_c *DbInterfaceMock_Watch_Call) Return(_a0 ChangeStreamInterface, _a1 error) *DbInterfaceMock_Watch_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DbInterfaceMock_Watch_Call) RunAndReturn(run func(interface{}) (ChangeStreamInterface, error)) *DbInterfaceMock_Watch_Call {
	_c.Call.Return(run)
	return _c
}

// NewDbInterfaceMock creates a new instance of DbInterfaceMock. 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 NewDbInterfaceMock(t interface {
	mock.TestingT
	Cleanup(func())
}) *DbInterfaceMock {
	mock := &DbInterfaceMock{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}