client_encryption.go

// Code generated by mockery. DO NOT EDIT.

package mocks

import (
	context "context"

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

	mock "github.com/stretchr/testify/mock"

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

	mongoifc "github.com/sv-tools/mongoifc"

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

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

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

type ClientEncryption_Expecter struct {
	mock *mock.Mock
}

func (_m *ClientEncryption) EXPECT() *ClientEncryption_Expecter {
	return &ClientEncryption_Expecter{mock: &_m.Mock}
}

// AddKeyAltName provides a mock function with given fields: ctx, id, keyAltName
func (_m *ClientEncryption) AddKeyAltName(ctx context.Context, id primitive.Binary, keyAltName string) mongoifc.SingleResult {
	ret := _m.Called(ctx, id, keyAltName)

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

	var r0 mongoifc.SingleResult
	if rf, ok := ret.Get(0).(func(context.Context, primitive.Binary, string) mongoifc.SingleResult); ok {
		r0 = rf(ctx, id, keyAltName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(mongoifc.SingleResult)
		}
	}

	return r0
}

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

// AddKeyAltName is a helper method to define mock.On call
//   - ctx context.Context
//   - id primitive.Binary
//   - keyAltName string
func (_e *ClientEncryption_Expecter) AddKeyAltName(ctx interface{}, id interface{}, keyAltName interface{}) *ClientEncryption_AddKeyAltName_Call {
	return &ClientEncryption_AddKeyAltName_Call{Call: _e.mock.On("AddKeyAltName", ctx, id, keyAltName)}
}

func (_c *ClientEncryption_AddKeyAltName_Call) Run(run func(ctx context.Context, id primitive.Binary, keyAltName string)) *ClientEncryption_AddKeyAltName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(primitive.Binary), args[2].(string))
	})
	return _c
}

func (_c *ClientEncryption_AddKeyAltName_Call) Return(_a0 mongoifc.SingleResult) *ClientEncryption_AddKeyAltName_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClientEncryption_AddKeyAltName_Call) RunAndReturn(run func(context.Context, primitive.Binary, string) mongoifc.SingleResult) *ClientEncryption_AddKeyAltName_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

// Close is a helper method to define mock.On call
//   - ctx context.Context
func (_e *ClientEncryption_Expecter) Close(ctx interface{}) *ClientEncryption_Close_Call {
	return &ClientEncryption_Close_Call{Call: _e.mock.On("Close", ctx)}
}

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

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

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

// CreateDataKey provides a mock function with given fields: ctx, kmsProvider, opts
func (_m *ClientEncryption) CreateDataKey(ctx context.Context, kmsProvider string, opts ...*options.DataKeyOptions) (primitive.Binary, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, kmsProvider)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 primitive.Binary
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, ...*options.DataKeyOptions) (primitive.Binary, error)); ok {
		return rf(ctx, kmsProvider, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, ...*options.DataKeyOptions) primitive.Binary); ok {
		r0 = rf(ctx, kmsProvider, opts...)
	} else {
		r0 = ret.Get(0).(primitive.Binary)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, ...*options.DataKeyOptions) error); ok {
		r1 = rf(ctx, kmsProvider, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateDataKey is a helper method to define mock.On call
//   - ctx context.Context
//   - kmsProvider string
//   - opts ...*options.DataKeyOptions
func (_e *ClientEncryption_Expecter) CreateDataKey(ctx interface{}, kmsProvider interface{}, opts ...interface{}) *ClientEncryption_CreateDataKey_Call {
	return &ClientEncryption_CreateDataKey_Call{Call: _e.mock.On("CreateDataKey",
		append([]interface{}{ctx, kmsProvider}, opts...)...)}
}

func (_c *ClientEncryption_CreateDataKey_Call) Run(run func(ctx context.Context, kmsProvider string, opts ...*options.DataKeyOptions)) *ClientEncryption_CreateDataKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]*options.DataKeyOptions, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(*options.DataKeyOptions)
			}
		}
		run(args[0].(context.Context), args[1].(string), variadicArgs...)
	})
	return _c
}

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

func (_c *ClientEncryption_CreateDataKey_Call) RunAndReturn(run func(context.Context, string, ...*options.DataKeyOptions) (primitive.Binary, error)) *ClientEncryption_CreateDataKey_Call {
	_c.Call.Return(run)
	return _c
}

// CreateEncryptedCollection provides a mock function with given fields: ctx, db, coll, createOpts, kmsProvider, masterKey
func (_m *ClientEncryption) CreateEncryptedCollection(ctx context.Context, db mongoifc.Database, coll string, createOpts *options.CreateCollectionOptions, kmsProvider string, masterKey interface{}) (mongoifc.Collection, primitive.M, error) {
	ret := _m.Called(ctx, db, coll, createOpts, kmsProvider, masterKey)

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

	var r0 mongoifc.Collection
	var r1 primitive.M
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, mongoifc.Database, string, *options.CreateCollectionOptions, string, interface{}) (mongoifc.Collection, primitive.M, error)); ok {
		return rf(ctx, db, coll, createOpts, kmsProvider, masterKey)
	}
	if rf, ok := ret.Get(0).(func(context.Context, mongoifc.Database, string, *options.CreateCollectionOptions, string, interface{}) mongoifc.Collection); ok {
		r0 = rf(ctx, db, coll, createOpts, kmsProvider, masterKey)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(mongoifc.Collection)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, mongoifc.Database, string, *options.CreateCollectionOptions, string, interface{}) primitive.M); ok {
		r1 = rf(ctx, db, coll, createOpts, kmsProvider, masterKey)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(primitive.M)
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, mongoifc.Database, string, *options.CreateCollectionOptions, string, interface{}) error); ok {
		r2 = rf(ctx, db, coll, createOpts, kmsProvider, masterKey)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// CreateEncryptedCollection is a helper method to define mock.On call
//   - ctx context.Context
//   - db mongoifc.Database
//   - coll string
//   - createOpts *options.CreateCollectionOptions
//   - kmsProvider string
//   - masterKey interface{}
func (_e *ClientEncryption_Expecter) CreateEncryptedCollection(ctx interface{}, db interface{}, coll interface{}, createOpts interface{}, kmsProvider interface{}, masterKey interface{}) *ClientEncryption_CreateEncryptedCollection_Call {
	return &ClientEncryption_CreateEncryptedCollection_Call{Call: _e.mock.On("CreateEncryptedCollection", ctx, db, coll, createOpts, kmsProvider, masterKey)}
}

func (_c *ClientEncryption_CreateEncryptedCollection_Call) Run(run func(ctx context.Context, db mongoifc.Database, coll string, createOpts *options.CreateCollectionOptions, kmsProvider string, masterKey interface{})) *ClientEncryption_CreateEncryptedCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(mongoifc.Database), args[2].(string), args[3].(*options.CreateCollectionOptions), args[4].(string), args[5].(interface{}))
	})
	return _c
}

func (_c *ClientEncryption_CreateEncryptedCollection_Call) Return(_a0 mongoifc.Collection, _a1 primitive.M, _a2 error) *ClientEncryption_CreateEncryptedCollection_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *ClientEncryption_CreateEncryptedCollection_Call) RunAndReturn(run func(context.Context, mongoifc.Database, string, *options.CreateCollectionOptions, string, interface{}) (mongoifc.Collection, primitive.M, error)) *ClientEncryption_CreateEncryptedCollection_Call {
	_c.Call.Return(run)
	return _c
}

// Decrypt provides a mock function with given fields: ctx, val
func (_m *ClientEncryption) Decrypt(ctx context.Context, val primitive.Binary) (bson.RawValue, error) {
	ret := _m.Called(ctx, val)

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

	var r0 bson.RawValue
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, primitive.Binary) (bson.RawValue, error)); ok {
		return rf(ctx, val)
	}
	if rf, ok := ret.Get(0).(func(context.Context, primitive.Binary) bson.RawValue); ok {
		r0 = rf(ctx, val)
	} else {
		r0 = ret.Get(0).(bson.RawValue)
	}

	if rf, ok := ret.Get(1).(func(context.Context, primitive.Binary) error); ok {
		r1 = rf(ctx, val)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Decrypt is a helper method to define mock.On call
//   - ctx context.Context
//   - val primitive.Binary
func (_e *ClientEncryption_Expecter) Decrypt(ctx interface{}, val interface{}) *ClientEncryption_Decrypt_Call {
	return &ClientEncryption_Decrypt_Call{Call: _e.mock.On("Decrypt", ctx, val)}
}

func (_c *ClientEncryption_Decrypt_Call) Run(run func(ctx context.Context, val primitive.Binary)) *ClientEncryption_Decrypt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(primitive.Binary))
	})
	return _c
}

func (_c *ClientEncryption_Decrypt_Call) Return(_a0 bson.RawValue, _a1 error) *ClientEncryption_Decrypt_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientEncryption_Decrypt_Call) RunAndReturn(run func(context.Context, primitive.Binary) (bson.RawValue, error)) *ClientEncryption_Decrypt_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteKey provides a mock function with given fields: ctx, id
func (_m *ClientEncryption) DeleteKey(ctx context.Context, id primitive.Binary) (*mongo.DeleteResult, error) {
	ret := _m.Called(ctx, id)

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

	var r0 *mongo.DeleteResult
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, primitive.Binary) (*mongo.DeleteResult, error)); ok {
		return rf(ctx, id)
	}
	if rf, ok := ret.Get(0).(func(context.Context, primitive.Binary) *mongo.DeleteResult); ok {
		r0 = rf(ctx, id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*mongo.DeleteResult)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, primitive.Binary) error); ok {
		r1 = rf(ctx, id)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteKey is a helper method to define mock.On call
//   - ctx context.Context
//   - id primitive.Binary
func (_e *ClientEncryption_Expecter) DeleteKey(ctx interface{}, id interface{}) *ClientEncryption_DeleteKey_Call {
	return &ClientEncryption_DeleteKey_Call{Call: _e.mock.On("DeleteKey", ctx, id)}
}

func (_c *ClientEncryption_DeleteKey_Call) Run(run func(ctx context.Context, id primitive.Binary)) *ClientEncryption_DeleteKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(primitive.Binary))
	})
	return _c
}

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

func (_c *ClientEncryption_DeleteKey_Call) RunAndReturn(run func(context.Context, primitive.Binary) (*mongo.DeleteResult, error)) *ClientEncryption_DeleteKey_Call {
	_c.Call.Return(run)
	return _c
}

// Encrypt provides a mock function with given fields: ctx, val, opts
func (_m *ClientEncryption) Encrypt(ctx context.Context, val bson.RawValue, opts ...*options.EncryptOptions) (primitive.Binary, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, val)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 primitive.Binary
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, bson.RawValue, ...*options.EncryptOptions) (primitive.Binary, error)); ok {
		return rf(ctx, val, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, bson.RawValue, ...*options.EncryptOptions) primitive.Binary); ok {
		r0 = rf(ctx, val, opts...)
	} else {
		r0 = ret.Get(0).(primitive.Binary)
	}

	if rf, ok := ret.Get(1).(func(context.Context, bson.RawValue, ...*options.EncryptOptions) error); ok {
		r1 = rf(ctx, val, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Encrypt is a helper method to define mock.On call
//   - ctx context.Context
//   - val bson.RawValue
//   - opts ...*options.EncryptOptions
func (_e *ClientEncryption_Expecter) Encrypt(ctx interface{}, val interface{}, opts ...interface{}) *ClientEncryption_Encrypt_Call {
	return &ClientEncryption_Encrypt_Call{Call: _e.mock.On("Encrypt",
		append([]interface{}{ctx, val}, opts...)...)}
}

func (_c *ClientEncryption_Encrypt_Call) Run(run func(ctx context.Context, val bson.RawValue, opts ...*options.EncryptOptions)) *ClientEncryption_Encrypt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]*options.EncryptOptions, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(*options.EncryptOptions)
			}
		}
		run(args[0].(context.Context), args[1].(bson.RawValue), variadicArgs...)
	})
	return _c
}

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

func (_c *ClientEncryption_Encrypt_Call) RunAndReturn(run func(context.Context, bson.RawValue, ...*options.EncryptOptions) (primitive.Binary, error)) *ClientEncryption_Encrypt_Call {
	_c.Call.Return(run)
	return _c
}

// EncryptExpression provides a mock function with given fields: ctx, expr, result, opts
func (_m *ClientEncryption) EncryptExpression(ctx context.Context, expr interface{}, result interface{}, opts ...*options.EncryptOptions) error {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, expr, result)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, interface{}, interface{}, ...*options.EncryptOptions) error); ok {
		r0 = rf(ctx, expr, result, opts...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// EncryptExpression is a helper method to define mock.On call
//   - ctx context.Context
//   - expr interface{}
//   - result interface{}
//   - opts ...*options.EncryptOptions
func (_e *ClientEncryption_Expecter) EncryptExpression(ctx interface{}, expr interface{}, result interface{}, opts ...interface{}) *ClientEncryption_EncryptExpression_Call {
	return &ClientEncryption_EncryptExpression_Call{Call: _e.mock.On("EncryptExpression",
		append([]interface{}{ctx, expr, result}, opts...)...)}
}

func (_c *ClientEncryption_EncryptExpression_Call) Run(run func(ctx context.Context, expr interface{}, result interface{}, opts ...*options.EncryptOptions)) *ClientEncryption_EncryptExpression_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]*options.EncryptOptions, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(*options.EncryptOptions)
			}
		}
		run(args[0].(context.Context), args[1].(interface{}), args[2].(interface{}), variadicArgs...)
	})
	return _c
}

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

func (_c *ClientEncryption_EncryptExpression_Call) RunAndReturn(run func(context.Context, interface{}, interface{}, ...*options.EncryptOptions) error) *ClientEncryption_EncryptExpression_Call {
	_c.Call.Return(run)
	return _c
}

// GetKey provides a mock function with given fields: ctx, id
func (_m *ClientEncryption) GetKey(ctx context.Context, id primitive.Binary) mongoifc.SingleResult {
	ret := _m.Called(ctx, id)

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

	var r0 mongoifc.SingleResult
	if rf, ok := ret.Get(0).(func(context.Context, primitive.Binary) mongoifc.SingleResult); ok {
		r0 = rf(ctx, id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(mongoifc.SingleResult)
		}
	}

	return r0
}

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

// GetKey is a helper method to define mock.On call
//   - ctx context.Context
//   - id primitive.Binary
func (_e *ClientEncryption_Expecter) GetKey(ctx interface{}, id interface{}) *ClientEncryption_GetKey_Call {
	return &ClientEncryption_GetKey_Call{Call: _e.mock.On("GetKey", ctx, id)}
}

func (_c *ClientEncryption_GetKey_Call) Run(run func(ctx context.Context, id primitive.Binary)) *ClientEncryption_GetKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(primitive.Binary))
	})
	return _c
}

func (_c *ClientEncryption_GetKey_Call) Return(_a0 mongoifc.SingleResult) *ClientEncryption_GetKey_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClientEncryption_GetKey_Call) RunAndReturn(run func(context.Context, primitive.Binary) mongoifc.SingleResult) *ClientEncryption_GetKey_Call {
	_c.Call.Return(run)
	return _c
}

// GetKeyByAltName provides a mock function with given fields: ctx, keyAltName
func (_m *ClientEncryption) GetKeyByAltName(ctx context.Context, keyAltName string) mongoifc.SingleResult {
	ret := _m.Called(ctx, keyAltName)

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

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

	return r0
}

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

// GetKeyByAltName is a helper method to define mock.On call
//   - ctx context.Context
//   - keyAltName string
func (_e *ClientEncryption_Expecter) GetKeyByAltName(ctx interface{}, keyAltName interface{}) *ClientEncryption_GetKeyByAltName_Call {
	return &ClientEncryption_GetKeyByAltName_Call{Call: _e.mock.On("GetKeyByAltName", ctx, keyAltName)}
}

func (_c *ClientEncryption_GetKeyByAltName_Call) Run(run func(ctx context.Context, keyAltName string)) *ClientEncryption_GetKeyByAltName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *ClientEncryption_GetKeyByAltName_Call) Return(_a0 mongoifc.SingleResult) *ClientEncryption_GetKeyByAltName_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClientEncryption_GetKeyByAltName_Call) RunAndReturn(run func(context.Context, string) mongoifc.SingleResult) *ClientEncryption_GetKeyByAltName_Call {
	_c.Call.Return(run)
	return _c
}

// GetKeys provides a mock function with given fields: ctx
func (_m *ClientEncryption) GetKeys(ctx context.Context) (mongoifc.Cursor, error) {
	ret := _m.Called(ctx)

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

	var r0 mongoifc.Cursor
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (mongoifc.Cursor, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) mongoifc.Cursor); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(mongoifc.Cursor)
		}
	}

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

	return r0, r1
}

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

// GetKeys is a helper method to define mock.On call
//   - ctx context.Context
func (_e *ClientEncryption_Expecter) GetKeys(ctx interface{}) *ClientEncryption_GetKeys_Call {
	return &ClientEncryption_GetKeys_Call{Call: _e.mock.On("GetKeys", ctx)}
}

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

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

func (_c *ClientEncryption_GetKeys_Call) RunAndReturn(run func(context.Context) (mongoifc.Cursor, error)) *ClientEncryption_GetKeys_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveKeyAltName provides a mock function with given fields: ctx, id, keyAltName
func (_m *ClientEncryption) RemoveKeyAltName(ctx context.Context, id primitive.Binary, keyAltName string) mongoifc.SingleResult {
	ret := _m.Called(ctx, id, keyAltName)

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

	var r0 mongoifc.SingleResult
	if rf, ok := ret.Get(0).(func(context.Context, primitive.Binary, string) mongoifc.SingleResult); ok {
		r0 = rf(ctx, id, keyAltName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(mongoifc.SingleResult)
		}
	}

	return r0
}

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

// RemoveKeyAltName is a helper method to define mock.On call
//   - ctx context.Context
//   - id primitive.Binary
//   - keyAltName string
func (_e *ClientEncryption_Expecter) RemoveKeyAltName(ctx interface{}, id interface{}, keyAltName interface{}) *ClientEncryption_RemoveKeyAltName_Call {
	return &ClientEncryption_RemoveKeyAltName_Call{Call: _e.mock.On("RemoveKeyAltName", ctx, id, keyAltName)}
}

func (_c *ClientEncryption_RemoveKeyAltName_Call) Run(run func(ctx context.Context, id primitive.Binary, keyAltName string)) *ClientEncryption_RemoveKeyAltName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(primitive.Binary), args[2].(string))
	})
	return _c
}

func (_c *ClientEncryption_RemoveKeyAltName_Call) Return(_a0 mongoifc.SingleResult) *ClientEncryption_RemoveKeyAltName_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClientEncryption_RemoveKeyAltName_Call) RunAndReturn(run func(context.Context, primitive.Binary, string) mongoifc.SingleResult) *ClientEncryption_RemoveKeyAltName_Call {
	_c.Call.Return(run)
	return _c
}

// RewrapManyDataKey provides a mock function with given fields: ctx, filter, opts
func (_m *ClientEncryption) RewrapManyDataKey(ctx context.Context, filter interface{}, opts ...*options.RewrapManyDataKeyOptions) (*mongo.RewrapManyDataKeyResult, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, filter)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

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

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

	return r0, r1
}

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

// RewrapManyDataKey is a helper method to define mock.On call
//   - ctx context.Context
//   - filter interface{}
//   - opts ...*options.RewrapManyDataKeyOptions
func (_e *ClientEncryption_Expecter) RewrapManyDataKey(ctx interface{}, filter interface{}, opts ...interface{}) *ClientEncryption_RewrapManyDataKey_Call {
	return &ClientEncryption_RewrapManyDataKey_Call{Call: _e.mock.On("RewrapManyDataKey",
		append([]interface{}{ctx, filter}, opts...)...)}
}

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

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

func (_c *ClientEncryption_RewrapManyDataKey_Call) RunAndReturn(run func(context.Context, interface{}, ...*options.RewrapManyDataKeyOptions) (*mongo.RewrapManyDataKeyResult, error)) *ClientEncryption_RewrapManyDataKey_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}