connector_test.go

// Code generated by mockery. DO NOT EDIT.

package mongodb_test

import (
	context "context"

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

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

	mongodb "github.com/mbretter/go-mongodb"

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

// ConnectorMock is an autogenerated mock type for the Connector type
type ConnectorMock struct {
	mock.Mock
}

type ConnectorMock_Expecter struct {
	mock *mock.Mock
}

func (_m *ConnectorMock) EXPECT() *ConnectorMock_Expecter {
	return &ConnectorMock_Expecter{mock: &_m.Mock}
}

// Aggregate provides a mock function with given fields: pipeline, opts
func (_m *ConnectorMock) Aggregate(pipeline interface{}, opts ...*options.AggregateOptions) (*mongo.Cursor, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, pipeline)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *mongo.Cursor
	var r1 error
	if rf, ok := ret.Get(0).(func(interface{}, ...*options.AggregateOptions) (*mongo.Cursor, error)); ok {
		return rf(pipeline, opts...)
	}
	if rf, ok := ret.Get(0).(func(interface{}, ...*options.AggregateOptions) *mongo.Cursor); ok {
		r0 = rf(pipeline, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*mongo.Cursor)
		}
	}

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

	return r0, r1
}

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

// Aggregate is a helper method to define mock.On call
//   - pipeline interface{}
//   - opts ...*options.AggregateOptions
func (_e *ConnectorMock_Expecter) Aggregate(pipeline interface{}, opts ...interface{}) *ConnectorMock_Aggregate_Call {
	return &ConnectorMock_Aggregate_Call{Call: _e.mock.On("Aggregate",
		append([]interface{}{pipeline}, opts...)...)}
}

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

func (_c *ConnectorMock_Aggregate_Call) Return(cur *mongo.Cursor, err error) *ConnectorMock_Aggregate_Call {
	_c.Call.Return(cur, err)
	return _c
}

func (_c *ConnectorMock_Aggregate_Call) RunAndReturn(run func(interface{}, ...*options.AggregateOptions) (*mongo.Cursor, error)) *ConnectorMock_Aggregate_Call {
	_c.Call.Return(run)
	return _c
}

// Collection provides a mock function with given fields: coll, opts
func (_m *ConnectorMock) Collection(coll string, opts ...*options.CollectionOptions) *mongo.Collection {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, coll)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *mongo.Collection
	if rf, ok := ret.Get(0).(func(string, ...*options.CollectionOptions) *mongo.Collection); ok {
		r0 = rf(coll, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*mongo.Collection)
		}
	}

	return r0
}

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

// Collection is a helper method to define mock.On call
//   - coll string
//   - opts ...*options.CollectionOptions
func (_e *ConnectorMock_Expecter) Collection(coll interface{}, opts ...interface{}) *ConnectorMock_Collection_Call {
	return &ConnectorMock_Collection_Call{Call: _e.mock.On("Collection",
		append([]interface{}{coll}, opts...)...)}
}

func (_c *ConnectorMock_Collection_Call) Run(run func(coll string, opts ...*options.CollectionOptions)) *ConnectorMock_Collection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]*options.CollectionOptions, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(*options.CollectionOptions)
			}
		}
		run(args[0].(string), variadicArgs...)
	})
	return _c
}

func (_c *ConnectorMock_Collection_Call) Return(_a0 *mongo.Collection) *ConnectorMock_Collection_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ConnectorMock_Collection_Call) RunAndReturn(run func(string, ...*options.CollectionOptions) *mongo.Collection) *ConnectorMock_Collection_Call {
	_c.Call.Return(run)
	return _c
}

// Count provides a mock function with given fields: filter, opts
func (_m *ConnectorMock) Count(filter interface{}, opts ...*options.CountOptions) (int64, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, filter)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func(interface{}, ...*options.CountOptions) (int64, error)); ok {
		return rf(filter, opts...)
	}
	if rf, ok := ret.Get(0).(func(interface{}, ...*options.CountOptions) int64); ok {
		r0 = rf(filter, opts...)
	} else {
		r0 = ret.Get(0).(int64)
	}

	if rf, ok := ret.Get(1).(func(interface{}, ...*options.CountOptions) error); ok {
		r1 = rf(filter, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Count is a helper method to define mock.On call
//   - filter interface{}
//   - opts ...*options.CountOptions
func (_e *ConnectorMock_Expecter) Count(filter interface{}, opts ...interface{}) *ConnectorMock_Count_Call {
	return &ConnectorMock_Count_Call{Call: _e.mock.On("Count",
		append([]interface{}{filter}, opts...)...)}
}

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

func (_c *ConnectorMock_Count_Call) Return(cnt int64, err error) *ConnectorMock_Count_Call {
	_c.Call.Return(cnt, err)
	return _c
}

func (_c *ConnectorMock_Count_Call) RunAndReturn(run func(interface{}, ...*options.CountOptions) (int64, error)) *ConnectorMock_Count_Call {
	_c.Call.Return(run)
	return _c
}

// Database provides a mock function with given fields:
func (_m *ConnectorMock) Database() *mongo.Database {
	ret := _m.Called()

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

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

	return r0
}

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

// Database is a helper method to define mock.On call
func (_e *ConnectorMock_Expecter) Database() *ConnectorMock_Database_Call {
	return &ConnectorMock_Database_Call{Call: _e.mock.On("Database")}
}

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

func (_c *ConnectorMock_Database_Call) Return(_a0 *mongo.Database) *ConnectorMock_Database_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ConnectorMock_Database_Call) RunAndReturn(run func() *mongo.Database) *ConnectorMock_Database_Call {
	_c.Call.Return(run)
	return _c
}

// Decode provides a mock function with given fields: cur, val
func (_m *ConnectorMock) Decode(cur *mongo.Cursor, val interface{}) error {
	ret := _m.Called(cur, val)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*mongo.Cursor, interface{}) error); ok {
		r0 = rf(cur, val)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Decode is a helper method to define mock.On call
//   - cur *mongo.Cursor
//   - val interface{}
func (_e *ConnectorMock_Expecter) Decode(cur interface{}, val interface{}) *ConnectorMock_Decode_Call {
	return &ConnectorMock_Decode_Call{Call: _e.mock.On("Decode", cur, val)}
}

func (_c *ConnectorMock_Decode_Call) Run(run func(cur *mongo.Cursor, val interface{})) *ConnectorMock_Decode_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*mongo.Cursor), args[1].(interface{}))
	})
	return _c
}

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

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

// DeleteMany provides a mock function with given fields: filter, opts
func (_m *ConnectorMock) DeleteMany(filter interface{}, opts ...*options.DeleteOptions) (*mongo.DeleteResult, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, filter)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *mongo.DeleteResult
	var r1 error
	if rf, ok := ret.Get(0).(func(interface{}, ...*options.DeleteOptions) (*mongo.DeleteResult, error)); ok {
		return rf(filter, opts...)
	}
	if rf, ok := ret.Get(0).(func(interface{}, ...*options.DeleteOptions) *mongo.DeleteResult); ok {
		r0 = rf(filter, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*mongo.DeleteResult)
		}
	}

	if rf, ok := ret.Get(1).(func(interface{}, ...*options.DeleteOptions) error); ok {
		r1 = rf(filter, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteMany is a helper method to define mock.On call
//   - filter interface{}
//   - opts ...*options.DeleteOptions
func (_e *ConnectorMock_Expecter) DeleteMany(filter interface{}, opts ...interface{}) *ConnectorMock_DeleteMany_Call {
	return &ConnectorMock_DeleteMany_Call{Call: _e.mock.On("DeleteMany",
		append([]interface{}{filter}, opts...)...)}
}

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

func (_c *ConnectorMock_DeleteMany_Call) Return(res *mongo.DeleteResult, err error) *ConnectorMock_DeleteMany_Call {
	_c.Call.Return(res, err)
	return _c
}

func (_c *ConnectorMock_DeleteMany_Call) RunAndReturn(run func(interface{}, ...*options.DeleteOptions) (*mongo.DeleteResult, error)) *ConnectorMock_DeleteMany_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteOne provides a mock function with given fields: filter, opts
func (_m *ConnectorMock) DeleteOne(filter interface{}, opts ...*options.DeleteOptions) (*mongo.DeleteResult, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, filter)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *mongo.DeleteResult
	var r1 error
	if rf, ok := ret.Get(0).(func(interface{}, ...*options.DeleteOptions) (*mongo.DeleteResult, error)); ok {
		return rf(filter, opts...)
	}
	if rf, ok := ret.Get(0).(func(interface{}, ...*options.DeleteOptions) *mongo.DeleteResult); ok {
		r0 = rf(filter, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*mongo.DeleteResult)
		}
	}

	if rf, ok := ret.Get(1).(func(interface{}, ...*options.DeleteOptions) error); ok {
		r1 = rf(filter, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteOne is a helper method to define mock.On call
//   - filter interface{}
//   - opts ...*options.DeleteOptions
func (_e *ConnectorMock_Expecter) DeleteOne(filter interface{}, opts ...interface{}) *ConnectorMock_DeleteOne_Call {
	return &ConnectorMock_DeleteOne_Call{Call: _e.mock.On("DeleteOne",
		append([]interface{}{filter}, opts...)...)}
}

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

func (_c *ConnectorMock_DeleteOne_Call) Return(res *mongo.DeleteResult, err error) *ConnectorMock_DeleteOne_Call {
	_c.Call.Return(res, err)
	return _c
}

func (_c *ConnectorMock_DeleteOne_Call) RunAndReturn(run func(interface{}, ...*options.DeleteOptions) (*mongo.DeleteResult, error)) *ConnectorMock_DeleteOne_Call {
	_c.Call.Return(run)
	return _c
}

// Distinct provides a mock function with given fields: fieldName, filter, opts
func (_m *ConnectorMock) Distinct(fieldName string, filter interface{}, opts ...*options.DistinctOptions) ([]interface{}, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, fieldName, filter)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 []interface{}
	var r1 error
	if rf, ok := ret.Get(0).(func(string, interface{}, ...*options.DistinctOptions) ([]interface{}, error)); ok {
		return rf(fieldName, filter, opts...)
	}
	if rf, ok := ret.Get(0).(func(string, interface{}, ...*options.DistinctOptions) []interface{}); ok {
		r0 = rf(fieldName, filter, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]interface{})
		}
	}

	if rf, ok := ret.Get(1).(func(string, interface{}, ...*options.DistinctOptions) error); ok {
		r1 = rf(fieldName, filter, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Distinct is a helper method to define mock.On call
//   - fieldName string
//   - filter interface{}
//   - opts ...*options.DistinctOptions
func (_e *ConnectorMock_Expecter) Distinct(fieldName interface{}, filter interface{}, opts ...interface{}) *ConnectorMock_Distinct_Call {
	return &ConnectorMock_Distinct_Call{Call: _e.mock.On("Distinct",
		append([]interface{}{fieldName, filter}, opts...)...)}
}

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

func (_c *ConnectorMock_Distinct_Call) Return(res []interface{}, err error) *ConnectorMock_Distinct_Call {
	_c.Call.Return(res, err)
	return _c
}

func (_c *ConnectorMock_Distinct_Call) RunAndReturn(run func(string, interface{}, ...*options.DistinctOptions) ([]interface{}, error)) *ConnectorMock_Distinct_Call {
	_c.Call.Return(run)
	return _c
}

// Drop provides a mock function with given fields:
func (_m *ConnectorMock) Drop() error {
	ret := _m.Called()

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

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

	return r0
}

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

// Drop is a helper method to define mock.On call
func (_e *ConnectorMock_Expecter) Drop() *ConnectorMock_Drop_Call {
	return &ConnectorMock_Drop_Call{Call: _e.mock.On("Drop")}
}

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

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

func (_c *ConnectorMock_Drop_Call) RunAndReturn(run func() error) *ConnectorMock_Drop_Call {
	_c.Call.Return(run)
	return _c
}

// FetchAll provides a mock function with given fields: cur, results
func (_m *ConnectorMock) FetchAll(cur *mongo.Cursor, results interface{}) error {
	ret := _m.Called(cur, results)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*mongo.Cursor, interface{}) error); ok {
		r0 = rf(cur, results)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// FetchAll is a helper method to define mock.On call
//   - cur *mongo.Cursor
//   - results interface{}
func (_e *ConnectorMock_Expecter) FetchAll(cur interface{}, results interface{}) *ConnectorMock_FetchAll_Call {
	return &ConnectorMock_FetchAll_Call{Call: _e.mock.On("FetchAll", cur, results)}
}

func (_c *ConnectorMock_FetchAll_Call) Run(run func(cur *mongo.Cursor, results interface{})) *ConnectorMock_FetchAll_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*mongo.Cursor), args[1].(interface{}))
	})
	return _c
}

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

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

// Find provides a mock function with given fields: filter, opts
func (_m *ConnectorMock) Find(filter interface{}, opts ...*options.FindOptions) (*mongo.Cursor, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, filter)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *mongo.Cursor
	var r1 error
	if rf, ok := ret.Get(0).(func(interface{}, ...*options.FindOptions) (*mongo.Cursor, error)); ok {
		return rf(filter, opts...)
	}
	if rf, ok := ret.Get(0).(func(interface{}, ...*options.FindOptions) *mongo.Cursor); ok {
		r0 = rf(filter, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*mongo.Cursor)
		}
	}

	if rf, ok := ret.Get(1).(func(interface{}, ...*options.FindOptions) error); ok {
		r1 = rf(filter, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Find is a helper method to define mock.On call
//   - filter interface{}
//   - opts ...*options.FindOptions
func (_e *ConnectorMock_Expecter) Find(filter interface{}, opts ...interface{}) *ConnectorMock_Find_Call {
	return &ConnectorMock_Find_Call{Call: _e.mock.On("Find",
		append([]interface{}{filter}, opts...)...)}
}

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

func (_c *ConnectorMock_Find_Call) Return(_a0 *mongo.Cursor, _a1 error) *ConnectorMock_Find_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ConnectorMock_Find_Call) RunAndReturn(run func(interface{}, ...*options.FindOptions) (*mongo.Cursor, error)) *ConnectorMock_Find_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

// FindOne is a helper method to define mock.On call
//   - filter interface{}
//   - opts ...*options.FindOneOptions
func (_e *ConnectorMock_Expecter) FindOne(filter interface{}, opts ...interface{}) *ConnectorMock_FindOne_Call {
	return &ConnectorMock_FindOne_Call{Call: _e.mock.On("FindOne",
		append([]interface{}{filter}, opts...)...)}
}

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

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

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

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

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

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

	return r0
}

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

// FindOneAndDelete is a helper method to define mock.On call
//   - filter interface{}
//   - opts ...*options.FindOneAndDeleteOptions
func (_e *ConnectorMock_Expecter) FindOneAndDelete(filter interface{}, opts ...interface{}) *ConnectorMock_FindOneAndDelete_Call {
	return &ConnectorMock_FindOneAndDelete_Call{Call: _e.mock.On("FindOneAndDelete",
		append([]interface{}{filter}, opts...)...)}
}

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

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

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

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

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

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

	return r0
}

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

// FindOneAndReplace is a helper method to define mock.On call
//   - filter interface{}
//   - replacement interface{}
//   - opts ...*options.FindOneAndReplaceOptions
func (_e *ConnectorMock_Expecter) FindOneAndReplace(filter interface{}, replacement interface{}, opts ...interface{}) *ConnectorMock_FindOneAndReplace_Call {
	return &ConnectorMock_FindOneAndReplace_Call{Call: _e.mock.On("FindOneAndReplace",
		append([]interface{}{filter, replacement}, opts...)...)}
}

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

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

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

// FindOneAndUpdate provides a mock function with given fields: filter, update, opts
func (_m *ConnectorMock) 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
}

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

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

func (_c *ConnectorMock_FindOneAndUpdate_Call) Run(run func(filter interface{}, update interface{}, opts ...*options.FindOneAndUpdateOptions)) *ConnectorMock_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 *ConnectorMock_FindOneAndUpdate_Call) Return(_a0 *mongo.SingleResult) *ConnectorMock_FindOneAndUpdate_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetNextSeq provides a mock function with given fields: name, opts
func (_m *ConnectorMock) GetNextSeq(name string, opts ...string) (int64, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, name)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func(string, ...string) (int64, error)); ok {
		return rf(name, opts...)
	}
	if rf, ok := ret.Get(0).(func(string, ...string) int64); ok {
		r0 = rf(name, opts...)
	} else {
		r0 = ret.Get(0).(int64)
	}

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

	return r0, r1
}

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

// GetNextSeq is a helper method to define mock.On call
//   - name string
//   - opts ...string
func (_e *ConnectorMock_Expecter) GetNextSeq(name interface{}, opts ...interface{}) *ConnectorMock_GetNextSeq_Call {
	return &ConnectorMock_GetNextSeq_Call{Call: _e.mock.On("GetNextSeq",
		append([]interface{}{name}, opts...)...)}
}

func (_c *ConnectorMock_GetNextSeq_Call) Run(run func(name string, opts ...string)) *ConnectorMock_GetNextSeq_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]string, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(string)
			}
		}
		run(args[0].(string), variadicArgs...)
	})
	return _c
}

func (_c *ConnectorMock_GetNextSeq_Call) Return(res int64, err error) *ConnectorMock_GetNextSeq_Call {
	_c.Call.Return(res, err)
	return _c
}

func (_c *ConnectorMock_GetNextSeq_Call) RunAndReturn(run func(string, ...string) (int64, error)) *ConnectorMock_GetNextSeq_Call {
	_c.Call.Return(run)
	return _c
}

// InsertMany provides a mock function with given fields: document, opts
func (_m *ConnectorMock) InsertMany(document []interface{}, opts ...*options.InsertManyOptions) (*mongo.InsertManyResult, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, document)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *mongo.InsertManyResult
	var r1 error
	if rf, ok := ret.Get(0).(func([]interface{}, ...*options.InsertManyOptions) (*mongo.InsertManyResult, error)); ok {
		return rf(document, opts...)
	}
	if rf, ok := ret.Get(0).(func([]interface{}, ...*options.InsertManyOptions) *mongo.InsertManyResult); ok {
		r0 = rf(document, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*mongo.InsertManyResult)
		}
	}

	if rf, ok := ret.Get(1).(func([]interface{}, ...*options.InsertManyOptions) error); ok {
		r1 = rf(document, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// InsertMany is a helper method to define mock.On call
//   - document []interface{}
//   - opts ...*options.InsertManyOptions
func (_e *ConnectorMock_Expecter) InsertMany(document interface{}, opts ...interface{}) *ConnectorMock_InsertMany_Call {
	return &ConnectorMock_InsertMany_Call{Call: _e.mock.On("InsertMany",
		append([]interface{}{document}, opts...)...)}
}

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

func (_c *ConnectorMock_InsertMany_Call) Return(res *mongo.InsertManyResult, err error) *ConnectorMock_InsertMany_Call {
	_c.Call.Return(res, err)
	return _c
}

func (_c *ConnectorMock_InsertMany_Call) RunAndReturn(run func([]interface{}, ...*options.InsertManyOptions) (*mongo.InsertManyResult, error)) *ConnectorMock_InsertMany_Call {
	_c.Call.Return(run)
	return _c
}

// InsertOne provides a mock function with given fields: document, opts
func (_m *ConnectorMock) InsertOne(document interface{}, opts ...*options.InsertOneOptions) (*mongo.InsertOneResult, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, document)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *mongo.InsertOneResult
	var r1 error
	if rf, ok := ret.Get(0).(func(interface{}, ...*options.InsertOneOptions) (*mongo.InsertOneResult, error)); ok {
		return rf(document, opts...)
	}
	if rf, ok := ret.Get(0).(func(interface{}, ...*options.InsertOneOptions) *mongo.InsertOneResult); ok {
		r0 = rf(document, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*mongo.InsertOneResult)
		}
	}

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

	return r0, r1
}

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

// InsertOne is a helper method to define mock.On call
//   - document interface{}
//   - opts ...*options.InsertOneOptions
func (_e *ConnectorMock_Expecter) InsertOne(document interface{}, opts ...interface{}) *ConnectorMock_InsertOne_Call {
	return &ConnectorMock_InsertOne_Call{Call: _e.mock.On("InsertOne",
		append([]interface{}{document}, opts...)...)}
}

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

func (_c *ConnectorMock_InsertOne_Call) Return(res *mongo.InsertOneResult, err error) *ConnectorMock_InsertOne_Call {
	_c.Call.Return(res, err)
	return _c
}

func (_c *ConnectorMock_InsertOne_Call) RunAndReturn(run func(interface{}, ...*options.InsertOneOptions) (*mongo.InsertOneResult, error)) *ConnectorMock_InsertOne_Call {
	_c.Call.Return(run)
	return _c
}

// NewGridfsBucket provides a mock function with given fields:
func (_m *ConnectorMock) NewGridfsBucket() (*gridfs.Bucket, error) {
	ret := _m.Called()

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

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

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

	return r0, r1
}

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

// NewGridfsBucket is a helper method to define mock.On call
func (_e *ConnectorMock_Expecter) NewGridfsBucket() *ConnectorMock_NewGridfsBucket_Call {
	return &ConnectorMock_NewGridfsBucket_Call{Call: _e.mock.On("NewGridfsBucket")}
}

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

func (_c *ConnectorMock_NewGridfsBucket_Call) Return(_a0 *gridfs.Bucket, _a1 error) *ConnectorMock_NewGridfsBucket_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ConnectorMock_NewGridfsBucket_Call) RunAndReturn(run func() (*gridfs.Bucket, error)) *ConnectorMock_NewGridfsBucket_Call {
	_c.Call.Return(run)
	return _c
}

// Next provides a mock function with given fields: cur
func (_m *ConnectorMock) Next(cur *mongo.Cursor) bool {
	ret := _m.Called(cur)

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

	var r0 bool
	if rf, ok := ret.Get(0).(func(*mongo.Cursor) bool); ok {
		r0 = rf(cur)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// Next is a helper method to define mock.On call
//   - cur *mongo.Cursor
func (_e *ConnectorMock_Expecter) Next(cur interface{}) *ConnectorMock_Next_Call {
	return &ConnectorMock_Next_Call{Call: _e.mock.On("Next", cur)}
}

func (_c *ConnectorMock_Next_Call) Run(run func(cur *mongo.Cursor)) *ConnectorMock_Next_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*mongo.Cursor))
	})
	return _c
}

func (_c *ConnectorMock_Next_Call) Return(_a0 bool) *ConnectorMock_Next_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ConnectorMock_Next_Call) RunAndReturn(run func(*mongo.Cursor) bool) *ConnectorMock_Next_Call {
	_c.Call.Return(run)
	return _c
}

// ReplaceOne provides a mock function with given fields: filter, update, opts
func (_m *ConnectorMock) ReplaceOne(filter interface{}, update interface{}, opts ...*options.ReplaceOptions) (*mongo.UpdateResult, error) {
	_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 ReplaceOne")
	}

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

	if rf, ok := ret.Get(1).(func(interface{}, interface{}, ...*options.ReplaceOptions) error); ok {
		r1 = rf(filter, update, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

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

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

func (_c *ConnectorMock_ReplaceOne_Call) Return(res *mongo.UpdateResult, err error) *ConnectorMock_ReplaceOne_Call {
	_c.Call.Return(res, err)
	return _c
}

func (_c *ConnectorMock_ReplaceOne_Call) RunAndReturn(run func(interface{}, interface{}, ...*options.ReplaceOptions) (*mongo.UpdateResult, error)) *ConnectorMock_ReplaceOne_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateById provides a mock function with given fields: id, update, opts
func (_m *ConnectorMock) UpdateById(id interface{}, update interface{}, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, id, update)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *mongo.UpdateResult
	var r1 error
	if rf, ok := ret.Get(0).(func(interface{}, interface{}, ...*options.UpdateOptions) (*mongo.UpdateResult, error)); ok {
		return rf(id, update, opts...)
	}
	if rf, ok := ret.Get(0).(func(interface{}, interface{}, ...*options.UpdateOptions) *mongo.UpdateResult); ok {
		r0 = rf(id, update, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*mongo.UpdateResult)
		}
	}

	if rf, ok := ret.Get(1).(func(interface{}, interface{}, ...*options.UpdateOptions) error); ok {
		r1 = rf(id, update, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateById is a helper method to define mock.On call
//   - id interface{}
//   - update interface{}
//   - opts ...*options.UpdateOptions
func (_e *ConnectorMock_Expecter) UpdateById(id interface{}, update interface{}, opts ...interface{}) *ConnectorMock_UpdateById_Call {
	return &ConnectorMock_UpdateById_Call{Call: _e.mock.On("UpdateById",
		append([]interface{}{id, update}, opts...)...)}
}

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

func (_c *ConnectorMock_UpdateById_Call) Return(res *mongo.UpdateResult, err error) *ConnectorMock_UpdateById_Call {
	_c.Call.Return(res, err)
	return _c
}

func (_c *ConnectorMock_UpdateById_Call) RunAndReturn(run func(interface{}, interface{}, ...*options.UpdateOptions) (*mongo.UpdateResult, error)) *ConnectorMock_UpdateById_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateMany provides a mock function with given fields: filter, update, opts
func (_m *ConnectorMock) UpdateMany(filter interface{}, update interface{}, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error) {
	_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 UpdateMany")
	}

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

	if rf, ok := ret.Get(1).(func(interface{}, interface{}, ...*options.UpdateOptions) error); ok {
		r1 = rf(filter, update, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

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

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

func (_c *ConnectorMock_UpdateMany_Call) Return(res *mongo.UpdateResult, err error) *ConnectorMock_UpdateMany_Call {
	_c.Call.Return(res, err)
	return _c
}

func (_c *ConnectorMock_UpdateMany_Call) RunAndReturn(run func(interface{}, interface{}, ...*options.UpdateOptions) (*mongo.UpdateResult, error)) *ConnectorMock_UpdateMany_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateOne provides a mock function with given fields: filter, update, opts
func (_m *ConnectorMock) UpdateOne(filter interface{}, update interface{}, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error) {
	_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 UpdateOne")
	}

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

	if rf, ok := ret.Get(1).(func(interface{}, interface{}, ...*options.UpdateOptions) error); ok {
		r1 = rf(filter, update, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

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

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

func (_c *ConnectorMock_UpdateOne_Call) Return(res *mongo.UpdateResult, err error) *ConnectorMock_UpdateOne_Call {
	_c.Call.Return(res, err)
	return _c
}

func (_c *ConnectorMock_UpdateOne_Call) RunAndReturn(run func(interface{}, interface{}, ...*options.UpdateOptions) (*mongo.UpdateResult, error)) *ConnectorMock_UpdateOne_Call {
	_c.Call.Return(run)
	return _c
}

// Watch provides a mock function with given fields: pipeline, opts
func (_m *ConnectorMock) Watch(pipeline interface{}, opts ...*options.ChangeStreamOptions) (*mongo.ChangeStream, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, pipeline)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *mongo.ChangeStream
	var r1 error
	if rf, ok := ret.Get(0).(func(interface{}, ...*options.ChangeStreamOptions) (*mongo.ChangeStream, error)); ok {
		return rf(pipeline, opts...)
	}
	if rf, ok := ret.Get(0).(func(interface{}, ...*options.ChangeStreamOptions) *mongo.ChangeStream); ok {
		r0 = rf(pipeline, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*mongo.ChangeStream)
		}
	}

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

	return r0, r1
}

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

// Watch is a helper method to define mock.On call
//   - pipeline interface{}
//   - opts ...*options.ChangeStreamOptions
func (_e *ConnectorMock_Expecter) Watch(pipeline interface{}, opts ...interface{}) *ConnectorMock_Watch_Call {
	return &ConnectorMock_Watch_Call{Call: _e.mock.On("Watch",
		append([]interface{}{pipeline}, opts...)...)}
}

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

func (_c *ConnectorMock_Watch_Call) Return(stream *mongo.ChangeStream, err error) *ConnectorMock_Watch_Call {
	_c.Call.Return(stream, err)
	return _c
}

func (_c *ConnectorMock_Watch_Call) RunAndReturn(run func(interface{}, ...*options.ChangeStreamOptions) (*mongo.ChangeStream, error)) *ConnectorMock_Watch_Call {
	_c.Call.Return(run)
	return _c
}

// WithCollection provides a mock function with given fields: coll, opts
func (_m *ConnectorMock) WithCollection(coll string, opts ...*options.CollectionOptions) mongodb.Connector {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, coll)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 mongodb.Connector
	if rf, ok := ret.Get(0).(func(string, ...*options.CollectionOptions) mongodb.Connector); ok {
		r0 = rf(coll, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(mongodb.Connector)
		}
	}

	return r0
}

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

// WithCollection is a helper method to define mock.On call
//   - coll string
//   - opts ...*options.CollectionOptions
func (_e *ConnectorMock_Expecter) WithCollection(coll interface{}, opts ...interface{}) *ConnectorMock_WithCollection_Call {
	return &ConnectorMock_WithCollection_Call{Call: _e.mock.On("WithCollection",
		append([]interface{}{coll}, opts...)...)}
}

func (_c *ConnectorMock_WithCollection_Call) Run(run func(coll string, opts ...*options.CollectionOptions)) *ConnectorMock_WithCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]*options.CollectionOptions, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(*options.CollectionOptions)
			}
		}
		run(args[0].(string), variadicArgs...)
	})
	return _c
}

func (_c *ConnectorMock_WithCollection_Call) Return(_a0 mongodb.Connector) *ConnectorMock_WithCollection_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ConnectorMock_WithCollection_Call) RunAndReturn(run func(string, ...*options.CollectionOptions) mongodb.Connector) *ConnectorMock_WithCollection_Call {
	_c.Call.Return(run)
	return _c
}

// WithContext provides a mock function with given fields: _a0
func (_m *ConnectorMock) WithContext(_a0 context.Context) mongodb.Connector {
	ret := _m.Called(_a0)

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

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

	return r0
}

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

// WithContext is a helper method to define mock.On call
//   - _a0 context.Context
func (_e *ConnectorMock_Expecter) WithContext(_a0 interface{}) *ConnectorMock_WithContext_Call {
	return &ConnectorMock_WithContext_Call{Call: _e.mock.On("WithContext", _a0)}
}

func (_c *ConnectorMock_WithContext_Call) Run(run func(_a0 context.Context)) *ConnectorMock_WithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *ConnectorMock_WithContext_Call) Return(_a0 mongodb.Connector) *ConnectorMock_WithContext_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ConnectorMock_WithContext_Call) RunAndReturn(run func(context.Context) mongodb.Connector) *ConnectorMock_WithContext_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}