mocks

package

Go to main page

Versions in this module

v1

v1.17.1

Nov 20, 2024

v1.17.0

Sep 24, 2024

Changes in this version

type IndexView

+ func (_m *IndexView) DropOneWithKey(ctx context.Context, keySpecDocument interface{}, ...) (bson.Raw, error)

+ type IndexView_DropOneWithKey_Call struct

+ func (_c *IndexView_DropOneWithKey_Call) Return(_a0 bson.Raw, _a1 error) *IndexView_DropOneWithKey_Call

+ func (_c *IndexView_DropOneWithKey_Call) Run(run func(ctx context.Context, keySpecDocument interface{}, ...)) *IndexView_DropOneWithKey_Call

+ func (_c *IndexView_DropOneWithKey_Call) RunAndReturn(...) *IndexView_DropOneWithKey_Call

type IndexView_Expecter

+ func (_e *IndexView_Expecter) DropOneWithKey(ctx interface{}, keySpecDocument interface{}, opts ...interface{}) *IndexView_DropOneWithKey_Call

v1.16.1

Aug 23, 2024

v1.16.0

Aug 22, 2024

v1.15.0

May 7, 2024

v1.14.0

Feb 24, 2024

v1.13.1

Jan 5, 2024

v1.13.0

Nov 14, 2023

Changes in this version

type ChangeStream

+ func (_m *ChangeStream) EXPECT() *ChangeStream_Expecter

+ func (_m *ChangeStream) SetBatchSize(size int32)

+ type ChangeStream_Close_Call struct

+ func (_c *ChangeStream_Close_Call) Return(_a0 error) *ChangeStream_Close_Call

+ func (_c *ChangeStream_Close_Call) Run(run func(ctx context.Context)) *ChangeStream_Close_Call

+ func (_c *ChangeStream_Close_Call) RunAndReturn(run func(context.Context) error) *ChangeStream_Close_Call

+ type ChangeStream_Current_Call struct

+ func (_c *ChangeStream_Current_Call) Return(_a0 bson.Raw) *ChangeStream_Current_Call

+ func (_c *ChangeStream_Current_Call) Run(run func()) *ChangeStream_Current_Call

+ func (_c *ChangeStream_Current_Call) RunAndReturn(run func() bson.Raw) *ChangeStream_Current_Call

+ type ChangeStream_Decode_Call struct

+ func (_c *ChangeStream_Decode_Call) Return(_a0 error) *ChangeStream_Decode_Call

+ func (_c *ChangeStream_Decode_Call) Run(run func(val interface{})) *ChangeStream_Decode_Call

+ func (_c *ChangeStream_Decode_Call) RunAndReturn(run func(interface{}) error) *ChangeStream_Decode_Call

+ type ChangeStream_Err_Call struct

+ func (_c *ChangeStream_Err_Call) Return(_a0 error) *ChangeStream_Err_Call

+ func (_c *ChangeStream_Err_Call) Run(run func()) *ChangeStream_Err_Call

+ func (_c *ChangeStream_Err_Call) RunAndReturn(run func() error) *ChangeStream_Err_Call

+ type ChangeStream_Expecter struct

+ func (_e *ChangeStream_Expecter) Close(ctx interface{}) *ChangeStream_Close_Call

+ func (_e *ChangeStream_Expecter) Current() *ChangeStream_Current_Call

+ func (_e *ChangeStream_Expecter) Decode(val interface{}) *ChangeStream_Decode_Call

+ func (_e *ChangeStream_Expecter) Err() *ChangeStream_Err_Call

+ func (_e *ChangeStream_Expecter) ID() *ChangeStream_ID_Call

+ func (_e *ChangeStream_Expecter) Next(ctx interface{}) *ChangeStream_Next_Call

+ func (_e *ChangeStream_Expecter) ResumeToken() *ChangeStream_ResumeToken_Call

+ func (_e *ChangeStream_Expecter) SetBatchSize(size interface{}) *ChangeStream_SetBatchSize_Call

+ func (_e *ChangeStream_Expecter) TryNext(ctx interface{}) *ChangeStream_TryNext_Call

+ type ChangeStream_ID_Call struct

+ func (_c *ChangeStream_ID_Call) Return(_a0 int64) *ChangeStream_ID_Call

+ func (_c *ChangeStream_ID_Call) Run(run func()) *ChangeStream_ID_Call

+ func (_c *ChangeStream_ID_Call) RunAndReturn(run func() int64) *ChangeStream_ID_Call

+ type ChangeStream_Next_Call struct

+ func (_c *ChangeStream_Next_Call) Return(_a0 bool) *ChangeStream_Next_Call

+ func (_c *ChangeStream_Next_Call) Run(run func(ctx context.Context)) *ChangeStream_Next_Call

+ func (_c *ChangeStream_Next_Call) RunAndReturn(run func(context.Context) bool) *ChangeStream_Next_Call

+ type ChangeStream_ResumeToken_Call struct

+ func (_c *ChangeStream_ResumeToken_Call) Return(_a0 bson.Raw) *ChangeStream_ResumeToken_Call

+ func (_c *ChangeStream_ResumeToken_Call) Run(run func()) *ChangeStream_ResumeToken_Call

+ func (_c *ChangeStream_ResumeToken_Call) RunAndReturn(run func() bson.Raw) *ChangeStream_ResumeToken_Call

+ type ChangeStream_SetBatchSize_Call struct

+ func (_c *ChangeStream_SetBatchSize_Call) Return() *ChangeStream_SetBatchSize_Call

+ func (_c *ChangeStream_SetBatchSize_Call) Run(run func(size int32)) *ChangeStream_SetBatchSize_Call

+ func (_c *ChangeStream_SetBatchSize_Call) RunAndReturn(run func(int32)) *ChangeStream_SetBatchSize_Call

+ type ChangeStream_TryNext_Call struct

+ func (_c *ChangeStream_TryNext_Call) Return(_a0 bool) *ChangeStream_TryNext_Call

+ func (_c *ChangeStream_TryNext_Call) Run(run func(ctx context.Context)) *ChangeStream_TryNext_Call

+ func (_c *ChangeStream_TryNext_Call) RunAndReturn(run func(context.Context) bool) *ChangeStream_TryNext_Call

type Client

+ func (_m *Client) EXPECT() *Client_Expecter

+ type ClientEncryption struct

+ func NewClientEncryption(t interface{ ... }) *ClientEncryption

+ func (_m *ClientEncryption) AddKeyAltName(ctx context.Context, id primitive.Binary, keyAltName string) mongoifc.SingleResult

+ func (_m *ClientEncryption) Close(ctx context.Context) error

+ func (_m *ClientEncryption) CreateDataKey(ctx context.Context, kmsProvider string, opts ...*options.DataKeyOptions) (primitive.Binary, error)

+ func (_m *ClientEncryption) CreateEncryptedCollection(ctx context.Context, db mongoifc.Database, coll string, ...) (mongoifc.Collection, primitive.M, error)

+ func (_m *ClientEncryption) Decrypt(ctx context.Context, val primitive.Binary) (bson.RawValue, error)

+ func (_m *ClientEncryption) DeleteKey(ctx context.Context, id primitive.Binary) (*mongo.DeleteResult, error)

+ func (_m *ClientEncryption) EXPECT() *ClientEncryption_Expecter

+ func (_m *ClientEncryption) Encrypt(ctx context.Context, val bson.RawValue, opts ...*options.EncryptOptions) (primitive.Binary, error)

+ func (_m *ClientEncryption) EncryptExpression(ctx context.Context, expr interface{}, result interface{}, ...) error

+ func (_m *ClientEncryption) GetKey(ctx context.Context, id primitive.Binary) mongoifc.SingleResult

+ func (_m *ClientEncryption) GetKeyByAltName(ctx context.Context, keyAltName string) mongoifc.SingleResult

+ func (_m *ClientEncryption) GetKeys(ctx context.Context) (mongoifc.Cursor, error)

+ func (_m *ClientEncryption) RemoveKeyAltName(ctx context.Context, id primitive.Binary, keyAltName string) mongoifc.SingleResult

+ func (_m *ClientEncryption) RewrapManyDataKey(ctx context.Context, filter interface{}, ...) (*mongo.RewrapManyDataKeyResult, error)

+ type ClientEncryption_AddKeyAltName_Call struct

+ func (_c *ClientEncryption_AddKeyAltName_Call) Return(_a0 mongoifc.SingleResult) *ClientEncryption_AddKeyAltName_Call

+ func (_c *ClientEncryption_AddKeyAltName_Call) Run(run func(ctx context.Context, id primitive.Binary, keyAltName string)) *ClientEncryption_AddKeyAltName_Call

+ func (_c *ClientEncryption_AddKeyAltName_Call) RunAndReturn(run func(context.Context, primitive.Binary, string) mongoifc.SingleResult) *ClientEncryption_AddKeyAltName_Call

+ type ClientEncryption_Close_Call struct

+ func (_c *ClientEncryption_Close_Call) Return(_a0 error) *ClientEncryption_Close_Call

+ func (_c *ClientEncryption_Close_Call) Run(run func(ctx context.Context)) *ClientEncryption_Close_Call

+ func (_c *ClientEncryption_Close_Call) RunAndReturn(run func(context.Context) error) *ClientEncryption_Close_Call

+ type ClientEncryption_CreateDataKey_Call struct

+ func (_c *ClientEncryption_CreateDataKey_Call) Return(_a0 primitive.Binary, _a1 error) *ClientEncryption_CreateDataKey_Call

+ func (_c *ClientEncryption_CreateDataKey_Call) Run(...) *ClientEncryption_CreateDataKey_Call

+ func (_c *ClientEncryption_CreateDataKey_Call) RunAndReturn(...) *ClientEncryption_CreateDataKey_Call

+ type ClientEncryption_CreateEncryptedCollection_Call struct

+ func (_c *ClientEncryption_CreateEncryptedCollection_Call) Return(_a0 mongoifc.Collection, _a1 primitive.M, _a2 error) *ClientEncryption_CreateEncryptedCollection_Call

+ func (_c *ClientEncryption_CreateEncryptedCollection_Call) Run(run func(ctx context.Context, db mongoifc.Database, coll string, ...)) *ClientEncryption_CreateEncryptedCollection_Call

+ func (_c *ClientEncryption_CreateEncryptedCollection_Call) RunAndReturn(...) *ClientEncryption_CreateEncryptedCollection_Call

+ type ClientEncryption_Decrypt_Call struct

+ func (_c *ClientEncryption_Decrypt_Call) Return(_a0 bson.RawValue, _a1 error) *ClientEncryption_Decrypt_Call

+ func (_c *ClientEncryption_Decrypt_Call) Run(run func(ctx context.Context, val primitive.Binary)) *ClientEncryption_Decrypt_Call

+ func (_c *ClientEncryption_Decrypt_Call) RunAndReturn(run func(context.Context, primitive.Binary) (bson.RawValue, error)) *ClientEncryption_Decrypt_Call

+ type ClientEncryption_DeleteKey_Call struct

+ func (_c *ClientEncryption_DeleteKey_Call) Return(_a0 *mongo.DeleteResult, _a1 error) *ClientEncryption_DeleteKey_Call

+ func (_c *ClientEncryption_DeleteKey_Call) Run(run func(ctx context.Context, id primitive.Binary)) *ClientEncryption_DeleteKey_Call

+ func (_c *ClientEncryption_DeleteKey_Call) RunAndReturn(run func(context.Context, primitive.Binary) (*mongo.DeleteResult, error)) *ClientEncryption_DeleteKey_Call

+ type ClientEncryption_EncryptExpression_Call struct

+ func (_c *ClientEncryption_EncryptExpression_Call) Return(_a0 error) *ClientEncryption_EncryptExpression_Call

+ func (_c *ClientEncryption_EncryptExpression_Call) Run(run func(ctx context.Context, expr interface{}, result interface{}, ...)) *ClientEncryption_EncryptExpression_Call

+ func (_c *ClientEncryption_EncryptExpression_Call) RunAndReturn(...) *ClientEncryption_EncryptExpression_Call

+ type ClientEncryption_Encrypt_Call struct

+ func (_c *ClientEncryption_Encrypt_Call) Return(_a0 primitive.Binary, _a1 error) *ClientEncryption_Encrypt_Call

+ func (_c *ClientEncryption_Encrypt_Call) Run(...) *ClientEncryption_Encrypt_Call

+ func (_c *ClientEncryption_Encrypt_Call) RunAndReturn(...) *ClientEncryption_Encrypt_Call

+ type ClientEncryption_Expecter struct

+ func (_e *ClientEncryption_Expecter) AddKeyAltName(ctx interface{}, id interface{}, keyAltName interface{}) *ClientEncryption_AddKeyAltName_Call

+ func (_e *ClientEncryption_Expecter) Close(ctx interface{}) *ClientEncryption_Close_Call

+ func (_e *ClientEncryption_Expecter) CreateDataKey(ctx interface{}, kmsProvider interface{}, opts ...interface{}) *ClientEncryption_CreateDataKey_Call

+ func (_e *ClientEncryption_Expecter) CreateEncryptedCollection(ctx interface{}, db interface{}, coll interface{}, createOpts interface{}, ...) *ClientEncryption_CreateEncryptedCollection_Call

+ func (_e *ClientEncryption_Expecter) Decrypt(ctx interface{}, val interface{}) *ClientEncryption_Decrypt_Call

+ func (_e *ClientEncryption_Expecter) DeleteKey(ctx interface{}, id interface{}) *ClientEncryption_DeleteKey_Call

+ func (_e *ClientEncryption_Expecter) Encrypt(ctx interface{}, val interface{}, opts ...interface{}) *ClientEncryption_Encrypt_Call

+ func (_e *ClientEncryption_Expecter) EncryptExpression(ctx interface{}, expr interface{}, result interface{}, opts ...interface{}) *ClientEncryption_EncryptExpression_Call

+ func (_e *ClientEncryption_Expecter) GetKey(ctx interface{}, id interface{}) *ClientEncryption_GetKey_Call

+ func (_e *ClientEncryption_Expecter) GetKeyByAltName(ctx interface{}, keyAltName interface{}) *ClientEncryption_GetKeyByAltName_Call

+ func (_e *ClientEncryption_Expecter) GetKeys(ctx interface{}) *ClientEncryption_GetKeys_Call

+ func (_e *ClientEncryption_Expecter) RemoveKeyAltName(ctx interface{}, id interface{}, keyAltName interface{}) *ClientEncryption_RemoveKeyAltName_Call

+ func (_e *ClientEncryption_Expecter) RewrapManyDataKey(ctx interface{}, filter interface{}, opts ...interface{}) *ClientEncryption_RewrapManyDataKey_Call

+ type ClientEncryption_GetKeyByAltName_Call struct

+ func (_c *ClientEncryption_GetKeyByAltName_Call) Return(_a0 mongoifc.SingleResult) *ClientEncryption_GetKeyByAltName_Call

+ func (_c *ClientEncryption_GetKeyByAltName_Call) Run(run func(ctx context.Context, keyAltName string)) *ClientEncryption_GetKeyByAltName_Call

+ func (_c *ClientEncryption_GetKeyByAltName_Call) RunAndReturn(run func(context.Context, string) mongoifc.SingleResult) *ClientEncryption_GetKeyByAltName_Call

+ type ClientEncryption_GetKey_Call struct

+ func (_c *ClientEncryption_GetKey_Call) Return(_a0 mongoifc.SingleResult) *ClientEncryption_GetKey_Call

+ func (_c *ClientEncryption_GetKey_Call) Run(run func(ctx context.Context, id primitive.Binary)) *ClientEncryption_GetKey_Call

+ func (_c *ClientEncryption_GetKey_Call) RunAndReturn(run func(context.Context, primitive.Binary) mongoifc.SingleResult) *ClientEncryption_GetKey_Call

+ type ClientEncryption_GetKeys_Call struct

+ func (_c *ClientEncryption_GetKeys_Call) Return(_a0 mongoifc.Cursor, _a1 error) *ClientEncryption_GetKeys_Call

+ func (_c *ClientEncryption_GetKeys_Call) Run(run func(ctx context.Context)) *ClientEncryption_GetKeys_Call

+ func (_c *ClientEncryption_GetKeys_Call) RunAndReturn(run func(context.Context) (mongoifc.Cursor, error)) *ClientEncryption_GetKeys_Call

+ type ClientEncryption_RemoveKeyAltName_Call struct

+ func (_c *ClientEncryption_RemoveKeyAltName_Call) Return(_a0 mongoifc.SingleResult) *ClientEncryption_RemoveKeyAltName_Call

+ func (_c *ClientEncryption_RemoveKeyAltName_Call) Run(run func(ctx context.Context, id primitive.Binary, keyAltName string)) *ClientEncryption_RemoveKeyAltName_Call

+ func (_c *ClientEncryption_RemoveKeyAltName_Call) RunAndReturn(run func(context.Context, primitive.Binary, string) mongoifc.SingleResult) *ClientEncryption_RemoveKeyAltName_Call

+ type ClientEncryption_RewrapManyDataKey_Call struct

+ func (_c *ClientEncryption_RewrapManyDataKey_Call) Return(_a0 *mongo.RewrapManyDataKeyResult, _a1 error) *ClientEncryption_RewrapManyDataKey_Call

+ func (_c *ClientEncryption_RewrapManyDataKey_Call) Run(run func(ctx context.Context, filter interface{}, ...)) *ClientEncryption_RewrapManyDataKey_Call

+ func (_c *ClientEncryption_RewrapManyDataKey_Call) RunAndReturn(...) *ClientEncryption_RewrapManyDataKey_Call

+ type Client_Connect_Call struct

+ func (_c *Client_Connect_Call) Return(_a0 error) *Client_Connect_Call

+ func (_c *Client_Connect_Call) Run(run func(ctx context.Context)) *Client_Connect_Call

+ func (_c *Client_Connect_Call) RunAndReturn(run func(context.Context) error) *Client_Connect_Call

+ type Client_Database_Call struct

+ func (_c *Client_Database_Call) Return(_a0 mongoifc.Database) *Client_Database_Call

+ func (_c *Client_Database_Call) Run(run func(name string, opts ...*options.DatabaseOptions)) *Client_Database_Call

+ func (_c *Client_Database_Call) RunAndReturn(run func(string, ...*options.DatabaseOptions) mongoifc.Database) *Client_Database_Call

+ type Client_Disconnect_Call struct

+ func (_c *Client_Disconnect_Call) Return(_a0 error) *Client_Disconnect_Call

+ func (_c *Client_Disconnect_Call) Run(run func(ctx context.Context)) *Client_Disconnect_Call

+ func (_c *Client_Disconnect_Call) RunAndReturn(run func(context.Context) error) *Client_Disconnect_Call

+ type Client_Expecter struct

+ func (_e *Client_Expecter) Connect(ctx interface{}) *Client_Connect_Call

+ func (_e *Client_Expecter) Database(name interface{}, opts ...interface{}) *Client_Database_Call

+ func (_e *Client_Expecter) Disconnect(ctx interface{}) *Client_Disconnect_Call

+ func (_e *Client_Expecter) ListDatabaseNames(ctx interface{}, filter interface{}, opts ...interface{}) *Client_ListDatabaseNames_Call

+ func (_e *Client_Expecter) ListDatabases(ctx interface{}, filter interface{}, opts ...interface{}) *Client_ListDatabases_Call

+ func (_e *Client_Expecter) NumberSessionsInProgress() *Client_NumberSessionsInProgress_Call

+ func (_e *Client_Expecter) Ping(ctx interface{}, rp interface{}) *Client_Ping_Call

+ func (_e *Client_Expecter) StartSession(opts ...interface{}) *Client_StartSession_Call

+ func (_e *Client_Expecter) Timeout() *Client_Timeout_Call

+ func (_e *Client_Expecter) UseSession(ctx interface{}, fn interface{}) *Client_UseSession_Call

+ func (_e *Client_Expecter) UseSessionWithOptions(ctx interface{}, opts interface{}, fn interface{}) *Client_UseSessionWithOptions_Call

+ func (_e *Client_Expecter) Watch(ctx interface{}, pipeline interface{}, opts ...interface{}) *Client_Watch_Call

+ type Client_ListDatabaseNames_Call struct

+ func (_c *Client_ListDatabaseNames_Call) Return(_a0 []string, _a1 error) *Client_ListDatabaseNames_Call

+ func (_c *Client_ListDatabaseNames_Call) Run(...) *Client_ListDatabaseNames_Call

+ func (_c *Client_ListDatabaseNames_Call) RunAndReturn(...) *Client_ListDatabaseNames_Call

+ type Client_ListDatabases_Call struct

+ func (_c *Client_ListDatabases_Call) Return(_a0 mongo.ListDatabasesResult, _a1 error) *Client_ListDatabases_Call

+ func (_c *Client_ListDatabases_Call) Run(...) *Client_ListDatabases_Call

+ func (_c *Client_ListDatabases_Call) RunAndReturn(...) *Client_ListDatabases_Call

+ type Client_NumberSessionsInProgress_Call struct

+ func (_c *Client_NumberSessionsInProgress_Call) Return(_a0 int) *Client_NumberSessionsInProgress_Call

+ func (_c *Client_NumberSessionsInProgress_Call) Run(run func()) *Client_NumberSessionsInProgress_Call

+ func (_c *Client_NumberSessionsInProgress_Call) RunAndReturn(run func() int) *Client_NumberSessionsInProgress_Call

+ type Client_Ping_Call struct

+ func (_c *Client_Ping_Call) Return(_a0 error) *Client_Ping_Call

+ func (_c *Client_Ping_Call) Run(run func(ctx context.Context, rp *readpref.ReadPref)) *Client_Ping_Call

+ func (_c *Client_Ping_Call) RunAndReturn(run func(context.Context, *readpref.ReadPref) error) *Client_Ping_Call

+ type Client_StartSession_Call struct

+ func (_c *Client_StartSession_Call) Return(_a0 mongoifc.Session, _a1 error) *Client_StartSession_Call

+ func (_c *Client_StartSession_Call) Run(run func(opts ...*options.SessionOptions)) *Client_StartSession_Call

+ func (_c *Client_StartSession_Call) RunAndReturn(run func(...*options.SessionOptions) (mongoifc.Session, error)) *Client_StartSession_Call

+ type Client_Timeout_Call struct

+ func (_c *Client_Timeout_Call) Return(_a0 *time.Duration) *Client_Timeout_Call

+ func (_c *Client_Timeout_Call) Run(run func()) *Client_Timeout_Call

+ func (_c *Client_Timeout_Call) RunAndReturn(run func() *time.Duration) *Client_Timeout_Call

+ type Client_UseSessionWithOptions_Call struct

+ func (_c *Client_UseSessionWithOptions_Call) Return(_a0 error) *Client_UseSessionWithOptions_Call

+ func (_c *Client_UseSessionWithOptions_Call) Run(run func(ctx context.Context, opts *options.SessionOptions, ...)) *Client_UseSessionWithOptions_Call

+ func (_c *Client_UseSessionWithOptions_Call) RunAndReturn(...) *Client_UseSessionWithOptions_Call

+ type Client_UseSession_Call struct

+ func (_c *Client_UseSession_Call) Return(_a0 error) *Client_UseSession_Call

+ func (_c *Client_UseSession_Call) Run(run func(ctx context.Context, fn func(mongoifc.SessionContext) error)) *Client_UseSession_Call

+ func (_c *Client_UseSession_Call) RunAndReturn(run func(context.Context, func(mongoifc.SessionContext) error) error) *Client_UseSession_Call

+ type Client_Watch_Call struct

+ func (_c *Client_Watch_Call) Return(_a0 mongoifc.ChangeStream, _a1 error) *Client_Watch_Call

+ func (_c *Client_Watch_Call) Run(run func(ctx context.Context, pipeline interface{}, ...)) *Client_Watch_Call

+ func (_c *Client_Watch_Call) RunAndReturn(...) *Client_Watch_Call

type Collection

+ func (_m *Collection) EXPECT() *Collection_Expecter

+ func (_m *Collection) SearchIndexes() mongoifc.SearchIndexView

+ type Collection_Aggregate_Call struct

+ func (_c *Collection_Aggregate_Call) Return(_a0 mongoifc.Cursor, _a1 error) *Collection_Aggregate_Call

+ func (_c *Collection_Aggregate_Call) Run(...) *Collection_Aggregate_Call

+ func (_c *Collection_Aggregate_Call) RunAndReturn(...) *Collection_Aggregate_Call

+ type Collection_BulkWrite_Call struct

+ func (_c *Collection_BulkWrite_Call) Return(_a0 *mongo.BulkWriteResult, _a1 error) *Collection_BulkWrite_Call

+ func (_c *Collection_BulkWrite_Call) Run(run func(ctx context.Context, models []mongo.WriteModel, ...)) *Collection_BulkWrite_Call

+ func (_c *Collection_BulkWrite_Call) RunAndReturn(...) *Collection_BulkWrite_Call

+ type Collection_Clone_Call struct

+ func (_c *Collection_Clone_Call) Return(_a0 mongoifc.Collection, _a1 error) *Collection_Clone_Call

+ func (_c *Collection_Clone_Call) Run(run func(opts ...*options.CollectionOptions)) *Collection_Clone_Call

+ func (_c *Collection_Clone_Call) RunAndReturn(run func(...*options.CollectionOptions) (mongoifc.Collection, error)) *Collection_Clone_Call

+ type Collection_CountDocuments_Call struct

+ func (_c *Collection_CountDocuments_Call) Return(_a0 int64, _a1 error) *Collection_CountDocuments_Call

+ func (_c *Collection_CountDocuments_Call) Run(...) *Collection_CountDocuments_Call

+ func (_c *Collection_CountDocuments_Call) RunAndReturn(...) *Collection_CountDocuments_Call

+ type Collection_Database_Call struct

+ func (_c *Collection_Database_Call) Return(_a0 mongoifc.Database) *Collection_Database_Call

+ func (_c *Collection_Database_Call) Run(run func()) *Collection_Database_Call

+ func (_c *Collection_Database_Call) RunAndReturn(run func() mongoifc.Database) *Collection_Database_Call

+ type Collection_DeleteMany_Call struct

+ func (_c *Collection_DeleteMany_Call) Return(_a0 *mongo.DeleteResult, _a1 error) *Collection_DeleteMany_Call

+ func (_c *Collection_DeleteMany_Call) Run(...) *Collection_DeleteMany_Call

+ func (_c *Collection_DeleteMany_Call) RunAndReturn(...) *Collection_DeleteMany_Call

+ type Collection_DeleteOne_Call struct

+ func (_c *Collection_DeleteOne_Call) Return(_a0 *mongo.DeleteResult, _a1 error) *Collection_DeleteOne_Call

+ func (_c *Collection_DeleteOne_Call) Run(...) *Collection_DeleteOne_Call

+ func (_c *Collection_DeleteOne_Call) RunAndReturn(...) *Collection_DeleteOne_Call

+ type Collection_Distinct_Call struct

+ func (_c *Collection_Distinct_Call) Return(_a0 []interface{}, _a1 error) *Collection_Distinct_Call

+ func (_c *Collection_Distinct_Call) Run(run func(ctx context.Context, fieldName string, filter interface{}, ...)) *Collection_Distinct_Call

+ func (_c *Collection_Distinct_Call) RunAndReturn(...) *Collection_Distinct_Call

+ type Collection_Drop_Call struct

+ func (_c *Collection_Drop_Call) Return(_a0 error) *Collection_Drop_Call

+ func (_c *Collection_Drop_Call) Run(run func(ctx context.Context)) *Collection_Drop_Call

+ func (_c *Collection_Drop_Call) RunAndReturn(run func(context.Context) error) *Collection_Drop_Call

+ type Collection_EstimatedDocumentCount_Call struct

+ func (_c *Collection_EstimatedDocumentCount_Call) Return(_a0 int64, _a1 error) *Collection_EstimatedDocumentCount_Call

+ func (_c *Collection_EstimatedDocumentCount_Call) Run(run func(ctx context.Context, opts ...*options.EstimatedDocumentCountOptions)) *Collection_EstimatedDocumentCount_Call

+ func (_c *Collection_EstimatedDocumentCount_Call) RunAndReturn(...) *Collection_EstimatedDocumentCount_Call

+ type Collection_Expecter struct

+ func (_e *Collection_Expecter) Aggregate(ctx interface{}, pipeline interface{}, opts ...interface{}) *Collection_Aggregate_Call

+ func (_e *Collection_Expecter) BulkWrite(ctx interface{}, models interface{}, opts ...interface{}) *Collection_BulkWrite_Call

+ func (_e *Collection_Expecter) Clone(opts ...interface{}) *Collection_Clone_Call

+ func (_e *Collection_Expecter) CountDocuments(ctx interface{}, filter interface{}, opts ...interface{}) *Collection_CountDocuments_Call

+ func (_e *Collection_Expecter) Database() *Collection_Database_Call

+ func (_e *Collection_Expecter) DeleteMany(ctx interface{}, filter interface{}, opts ...interface{}) *Collection_DeleteMany_Call

+ func (_e *Collection_Expecter) DeleteOne(ctx interface{}, filter interface{}, opts ...interface{}) *Collection_DeleteOne_Call

+ func (_e *Collection_Expecter) Distinct(ctx interface{}, fieldName interface{}, filter interface{}, ...) *Collection_Distinct_Call

+ func (_e *Collection_Expecter) Drop(ctx interface{}) *Collection_Drop_Call

+ func (_e *Collection_Expecter) EstimatedDocumentCount(ctx interface{}, opts ...interface{}) *Collection_EstimatedDocumentCount_Call

+ func (_e *Collection_Expecter) Find(ctx interface{}, filter interface{}, opts ...interface{}) *Collection_Find_Call

+ func (_e *Collection_Expecter) FindOne(ctx interface{}, filter interface{}, opts ...interface{}) *Collection_FindOne_Call

+ func (_e *Collection_Expecter) FindOneAndDelete(ctx interface{}, filter interface{}, opts ...interface{}) *Collection_FindOneAndDelete_Call

+ func (_e *Collection_Expecter) FindOneAndReplace(ctx interface{}, filter interface{}, replacement interface{}, ...) *Collection_FindOneAndReplace_Call

+ func (_e *Collection_Expecter) FindOneAndUpdate(ctx interface{}, filter interface{}, update interface{}, opts ...interface{}) *Collection_FindOneAndUpdate_Call

+ func (_e *Collection_Expecter) Indexes() *Collection_Indexes_Call

+ func (_e *Collection_Expecter) InsertMany(ctx interface{}, documents interface{}, opts ...interface{}) *Collection_InsertMany_Call

+ func (_e *Collection_Expecter) InsertOne(ctx interface{}, document interface{}, opts ...interface{}) *Collection_InsertOne_Call

+ func (_e *Collection_Expecter) Name() *Collection_Name_Call

+ func (_e *Collection_Expecter) ReplaceOne(ctx interface{}, filter interface{}, replacement interface{}, ...) *Collection_ReplaceOne_Call

+ func (_e *Collection_Expecter) SearchIndexes() *Collection_SearchIndexes_Call

+ func (_e *Collection_Expecter) UpdateByID(ctx interface{}, id interface{}, update interface{}, opts ...interface{}) *Collection_UpdateByID_Call

+ func (_e *Collection_Expecter) UpdateMany(ctx interface{}, filter interface{}, update interface{}, opts ...interface{}) *Collection_UpdateMany_Call

+ func (_e *Collection_Expecter) UpdateOne(ctx interface{}, filter interface{}, update interface{}, opts ...interface{}) *Collection_UpdateOne_Call

+ func (_e *Collection_Expecter) Watch(ctx interface{}, pipeline interface{}, opts ...interface{}) *Collection_Watch_Call

+ type Collection_FindOneAndDelete_Call struct

+ func (_c *Collection_FindOneAndDelete_Call) Return(_a0 mongoifc.SingleResult) *Collection_FindOneAndDelete_Call

+ func (_c *Collection_FindOneAndDelete_Call) Run(run func(ctx context.Context, filter interface{}, ...)) *Collection_FindOneAndDelete_Call

+ func (_c *Collection_FindOneAndDelete_Call) RunAndReturn(...) *Collection_FindOneAndDelete_Call

+ type Collection_FindOneAndReplace_Call struct

+ func (_c *Collection_FindOneAndReplace_Call) Return(_a0 mongoifc.SingleResult) *Collection_FindOneAndReplace_Call

+ func (_c *Collection_FindOneAndReplace_Call) Run(...) *Collection_FindOneAndReplace_Call

+ func (_c *Collection_FindOneAndReplace_Call) RunAndReturn(run func(context.Context, interface{}, interface{}, ...) mongoifc.SingleResult) *Collection_FindOneAndReplace_Call

+ type Collection_FindOneAndUpdate_Call struct

+ func (_c *Collection_FindOneAndUpdate_Call) Return(_a0 mongoifc.SingleResult) *Collection_FindOneAndUpdate_Call

+ func (_c *Collection_FindOneAndUpdate_Call) Run(run func(ctx context.Context, filter interface{}, update interface{}, ...)) *Collection_FindOneAndUpdate_Call

+ func (_c *Collection_FindOneAndUpdate_Call) RunAndReturn(...) *Collection_FindOneAndUpdate_Call

+ type Collection_FindOne_Call struct

+ func (_c *Collection_FindOne_Call) Return(_a0 mongoifc.SingleResult) *Collection_FindOne_Call

+ func (_c *Collection_FindOne_Call) Run(...) *Collection_FindOne_Call

+ func (_c *Collection_FindOne_Call) RunAndReturn(...) *Collection_FindOne_Call

+ type Collection_Find_Call struct

+ func (_c *Collection_Find_Call) Return(_a0 mongoifc.Cursor, _a1 error) *Collection_Find_Call

+ func (_c *Collection_Find_Call) Run(...) *Collection_Find_Call

+ func (_c *Collection_Find_Call) RunAndReturn(...) *Collection_Find_Call

+ type Collection_Indexes_Call struct

+ func (_c *Collection_Indexes_Call) Return(_a0 mongoifc.IndexView) *Collection_Indexes_Call

+ func (_c *Collection_Indexes_Call) Run(run func()) *Collection_Indexes_Call

+ func (_c *Collection_Indexes_Call) RunAndReturn(run func() mongoifc.IndexView) *Collection_Indexes_Call

+ type Collection_InsertMany_Call struct

+ func (_c *Collection_InsertMany_Call) Return(_a0 *mongo.InsertManyResult, _a1 error) *Collection_InsertMany_Call

+ func (_c *Collection_InsertMany_Call) Run(run func(ctx context.Context, documents []interface{}, ...)) *Collection_InsertMany_Call

+ func (_c *Collection_InsertMany_Call) RunAndReturn(...) *Collection_InsertMany_Call

+ type Collection_InsertOne_Call struct

+ func (_c *Collection_InsertOne_Call) Return(_a0 *mongo.InsertOneResult, _a1 error) *Collection_InsertOne_Call

+ func (_c *Collection_InsertOne_Call) Run(...) *Collection_InsertOne_Call

+ func (_c *Collection_InsertOne_Call) RunAndReturn(...) *Collection_InsertOne_Call

+ type Collection_Name_Call struct

+ func (_c *Collection_Name_Call) Return(_a0 string) *Collection_Name_Call

+ func (_c *Collection_Name_Call) Run(run func()) *Collection_Name_Call

+ func (_c *Collection_Name_Call) RunAndReturn(run func() string) *Collection_Name_Call

+ type Collection_ReplaceOne_Call struct

+ func (_c *Collection_ReplaceOne_Call) Return(_a0 *mongo.UpdateResult, _a1 error) *Collection_ReplaceOne_Call

+ func (_c *Collection_ReplaceOne_Call) Run(...) *Collection_ReplaceOne_Call

+ func (_c *Collection_ReplaceOne_Call) RunAndReturn(...) *Collection_ReplaceOne_Call

+ type Collection_SearchIndexes_Call struct

+ func (_c *Collection_SearchIndexes_Call) Return(_a0 mongoifc.SearchIndexView) *Collection_SearchIndexes_Call

+ func (_c *Collection_SearchIndexes_Call) Run(run func()) *Collection_SearchIndexes_Call

+ func (_c *Collection_SearchIndexes_Call) RunAndReturn(run func() mongoifc.SearchIndexView) *Collection_SearchIndexes_Call

+ type Collection_UpdateByID_Call struct

+ func (_c *Collection_UpdateByID_Call) Return(_a0 *mongo.UpdateResult, _a1 error) *Collection_UpdateByID_Call

+ func (_c *Collection_UpdateByID_Call) Run(run func(ctx context.Context, id interface{}, update interface{}, ...)) *Collection_UpdateByID_Call

+ func (_c *Collection_UpdateByID_Call) RunAndReturn(...) *Collection_UpdateByID_Call

+ type Collection_UpdateMany_Call struct

+ func (_c *Collection_UpdateMany_Call) Return(_a0 *mongo.UpdateResult, _a1 error) *Collection_UpdateMany_Call

+ func (_c *Collection_UpdateMany_Call) Run(run func(ctx context.Context, filter interface{}, update interface{}, ...)) *Collection_UpdateMany_Call

+ func (_c *Collection_UpdateMany_Call) RunAndReturn(...) *Collection_UpdateMany_Call

+ type Collection_UpdateOne_Call struct

+ func (_c *Collection_UpdateOne_Call) Return(_a0 *mongo.UpdateResult, _a1 error) *Collection_UpdateOne_Call

+ func (_c *Collection_UpdateOne_Call) Run(run func(ctx context.Context, filter interface{}, update interface{}, ...)) *Collection_UpdateOne_Call

+ func (_c *Collection_UpdateOne_Call) RunAndReturn(...) *Collection_UpdateOne_Call

+ type Collection_Watch_Call struct

+ func (_c *Collection_Watch_Call) Return(_a0 mongoifc.ChangeStream, _a1 error) *Collection_Watch_Call

+ func (_c *Collection_Watch_Call) Run(run func(ctx context.Context, pipeline interface{}, ...)) *Collection_Watch_Call

+ func (_c *Collection_Watch_Call) RunAndReturn(...) *Collection_Watch_Call

type Cursor

+ func (_m *Cursor) EXPECT() *Cursor_Expecter

+ func (_m *Cursor) SetBatchSize(batchSize int32)

+ func (_m *Cursor) SetComment(comment interface{})

+ func (_m *Cursor) SetMaxTime(dur time.Duration)

+ type Cursor_All_Call struct

+ func (_c *Cursor_All_Call) Return(_a0 error) *Cursor_All_Call

+ func (_c *Cursor_All_Call) Run(run func(ctx context.Context, results interface{})) *Cursor_All_Call

+ func (_c *Cursor_All_Call) RunAndReturn(run func(context.Context, interface{}) error) *Cursor_All_Call

+ type Cursor_Close_Call struct

+ func (_c *Cursor_Close_Call) Return(_a0 error) *Cursor_Close_Call

+ func (_c *Cursor_Close_Call) Run(run func(ctx context.Context)) *Cursor_Close_Call

+ func (_c *Cursor_Close_Call) RunAndReturn(run func(context.Context) error) *Cursor_Close_Call

+ type Cursor_Current_Call struct

+ func (_c *Cursor_Current_Call) Return(_a0 bson.Raw) *Cursor_Current_Call

+ func (_c *Cursor_Current_Call) Run(run func()) *Cursor_Current_Call

+ func (_c *Cursor_Current_Call) RunAndReturn(run func() bson.Raw) *Cursor_Current_Call

+ type Cursor_Decode_Call struct

+ func (_c *Cursor_Decode_Call) Return(_a0 error) *Cursor_Decode_Call

+ func (_c *Cursor_Decode_Call) Run(run func(val interface{})) *Cursor_Decode_Call

+ func (_c *Cursor_Decode_Call) RunAndReturn(run func(interface{}) error) *Cursor_Decode_Call

+ type Cursor_Err_Call struct

+ func (_c *Cursor_Err_Call) Return(_a0 error) *Cursor_Err_Call

+ func (_c *Cursor_Err_Call) Run(run func()) *Cursor_Err_Call

+ func (_c *Cursor_Err_Call) RunAndReturn(run func() error) *Cursor_Err_Call

+ type Cursor_Expecter struct

+ func (_e *Cursor_Expecter) All(ctx interface{}, results interface{}) *Cursor_All_Call

+ func (_e *Cursor_Expecter) Close(ctx interface{}) *Cursor_Close_Call

+ func (_e *Cursor_Expecter) Current() *Cursor_Current_Call

+ func (_e *Cursor_Expecter) Decode(val interface{}) *Cursor_Decode_Call

+ func (_e *Cursor_Expecter) Err() *Cursor_Err_Call

+ func (_e *Cursor_Expecter) ID() *Cursor_ID_Call

+ func (_e *Cursor_Expecter) Next(ctx interface{}) *Cursor_Next_Call

+ func (_e *Cursor_Expecter) RemainingBatchLength() *Cursor_RemainingBatchLength_Call

+ func (_e *Cursor_Expecter) SetBatchSize(batchSize interface{}) *Cursor_SetBatchSize_Call

+ func (_e *Cursor_Expecter) SetComment(comment interface{}) *Cursor_SetComment_Call

+ func (_e *Cursor_Expecter) SetMaxTime(dur interface{}) *Cursor_SetMaxTime_Call

+ func (_e *Cursor_Expecter) TryNext(ctx interface{}) *Cursor_TryNext_Call

+ type Cursor_ID_Call struct

+ func (_c *Cursor_ID_Call) Return(_a0 int64) *Cursor_ID_Call

+ func (_c *Cursor_ID_Call) Run(run func()) *Cursor_ID_Call

+ func (_c *Cursor_ID_Call) RunAndReturn(run func() int64) *Cursor_ID_Call

+ type Cursor_Next_Call struct

+ func (_c *Cursor_Next_Call) Return(_a0 bool) *Cursor_Next_Call

+ func (_c *Cursor_Next_Call) Run(run func(ctx context.Context)) *Cursor_Next_Call

+ func (_c *Cursor_Next_Call) RunAndReturn(run func(context.Context) bool) *Cursor_Next_Call

+ type Cursor_RemainingBatchLength_Call struct

+ func (_c *Cursor_RemainingBatchLength_Call) Return(_a0 int) *Cursor_RemainingBatchLength_Call

+ func (_c *Cursor_RemainingBatchLength_Call) Run(run func()) *Cursor_RemainingBatchLength_Call

+ func (_c *Cursor_RemainingBatchLength_Call) RunAndReturn(run func() int) *Cursor_RemainingBatchLength_Call

+ type Cursor_SetBatchSize_Call struct

+ func (_c *Cursor_SetBatchSize_Call) Return() *Cursor_SetBatchSize_Call

+ func (_c *Cursor_SetBatchSize_Call) Run(run func(batchSize int32)) *Cursor_SetBatchSize_Call

+ func (_c *Cursor_SetBatchSize_Call) RunAndReturn(run func(int32)) *Cursor_SetBatchSize_Call

+ type Cursor_SetComment_Call struct

+ func (_c *Cursor_SetComment_Call) Return() *Cursor_SetComment_Call

+ func (_c *Cursor_SetComment_Call) Run(run func(comment interface{})) *Cursor_SetComment_Call

+ func (_c *Cursor_SetComment_Call) RunAndReturn(run func(interface{})) *Cursor_SetComment_Call

+ type Cursor_SetMaxTime_Call struct

+ func (_c *Cursor_SetMaxTime_Call) Return() *Cursor_SetMaxTime_Call

+ func (_c *Cursor_SetMaxTime_Call) Run(run func(dur time.Duration)) *Cursor_SetMaxTime_Call

+ func (_c *Cursor_SetMaxTime_Call) RunAndReturn(run func(time.Duration)) *Cursor_SetMaxTime_Call

+ type Cursor_TryNext_Call struct

+ func (_c *Cursor_TryNext_Call) Return(_a0 bool) *Cursor_TryNext_Call

+ func (_c *Cursor_TryNext_Call) Run(run func(ctx context.Context)) *Cursor_TryNext_Call

+ func (_c *Cursor_TryNext_Call) RunAndReturn(run func(context.Context) bool) *Cursor_TryNext_Call

type Database

+ func (_m *Database) EXPECT() *Database_Expecter

+ type Database_Aggregate_Call struct

+ func (_c *Database_Aggregate_Call) Return(_a0 mongoifc.Cursor, _a1 error) *Database_Aggregate_Call

+ func (_c *Database_Aggregate_Call) Run(...) *Database_Aggregate_Call

+ func (_c *Database_Aggregate_Call) RunAndReturn(...) *Database_Aggregate_Call

+ type Database_Client_Call struct

+ func (_c *Database_Client_Call) Return(_a0 mongoifc.Client) *Database_Client_Call

+ func (_c *Database_Client_Call) Run(run func()) *Database_Client_Call

+ func (_c *Database_Client_Call) RunAndReturn(run func() mongoifc.Client) *Database_Client_Call

+ type Database_Collection_Call struct

+ func (_c *Database_Collection_Call) Return(_a0 mongoifc.Collection) *Database_Collection_Call

+ func (_c *Database_Collection_Call) Run(run func(name string, opts ...*options.CollectionOptions)) *Database_Collection_Call

+ func (_c *Database_Collection_Call) RunAndReturn(run func(string, ...*options.CollectionOptions) mongoifc.Collection) *Database_Collection_Call

+ type Database_CreateCollection_Call struct

+ func (_c *Database_CreateCollection_Call) Return(_a0 error) *Database_CreateCollection_Call

+ func (_c *Database_CreateCollection_Call) Run(...) *Database_CreateCollection_Call

+ func (_c *Database_CreateCollection_Call) RunAndReturn(run func(context.Context, string, ...*options.CreateCollectionOptions) error) *Database_CreateCollection_Call

+ type Database_CreateView_Call struct

+ func (_c *Database_CreateView_Call) Return(_a0 error) *Database_CreateView_Call

+ func (_c *Database_CreateView_Call) Run(...) *Database_CreateView_Call

+ func (_c *Database_CreateView_Call) RunAndReturn(...) *Database_CreateView_Call

+ type Database_Drop_Call struct

+ func (_c *Database_Drop_Call) Return(_a0 error) *Database_Drop_Call

+ func (_c *Database_Drop_Call) Run(run func(ctx context.Context)) *Database_Drop_Call

+ func (_c *Database_Drop_Call) RunAndReturn(run func(context.Context) error) *Database_Drop_Call

+ type Database_Expecter struct

+ func (_e *Database_Expecter) Aggregate(ctx interface{}, pipeline interface{}, opts ...interface{}) *Database_Aggregate_Call

+ func (_e *Database_Expecter) Client() *Database_Client_Call

+ func (_e *Database_Expecter) Collection(name interface{}, opts ...interface{}) *Database_Collection_Call

+ func (_e *Database_Expecter) CreateCollection(ctx interface{}, name interface{}, opts ...interface{}) *Database_CreateCollection_Call

+ func (_e *Database_Expecter) CreateView(ctx interface{}, viewName interface{}, viewOn interface{}, ...) *Database_CreateView_Call

+ func (_e *Database_Expecter) Drop(ctx interface{}) *Database_Drop_Call

+ func (_e *Database_Expecter) ListCollectionNames(ctx interface{}, filter interface{}, opts ...interface{}) *Database_ListCollectionNames_Call

+ func (_e *Database_Expecter) ListCollectionSpecifications(ctx interface{}, filter interface{}, opts ...interface{}) *Database_ListCollectionSpecifications_Call

+ func (_e *Database_Expecter) ListCollections(ctx interface{}, filter interface{}, opts ...interface{}) *Database_ListCollections_Call

+ func (_e *Database_Expecter) Name() *Database_Name_Call

+ func (_e *Database_Expecter) ReadConcern() *Database_ReadConcern_Call

+ func (_e *Database_Expecter) ReadPreference() *Database_ReadPreference_Call

+ func (_e *Database_Expecter) RunCommand(ctx interface{}, runCommand interface{}, opts ...interface{}) *Database_RunCommand_Call

+ func (_e *Database_Expecter) RunCommandCursor(ctx interface{}, runCommand interface{}, opts ...interface{}) *Database_RunCommandCursor_Call

+ func (_e *Database_Expecter) Watch(ctx interface{}, pipeline interface{}, opts ...interface{}) *Database_Watch_Call

+ func (_e *Database_Expecter) WriteConcern() *Database_WriteConcern_Call

+ type Database_ListCollectionNames_Call struct

+ func (_c *Database_ListCollectionNames_Call) Return(_a0 []string, _a1 error) *Database_ListCollectionNames_Call

+ func (_c *Database_ListCollectionNames_Call) Run(run func(ctx context.Context, filter interface{}, ...)) *Database_ListCollectionNames_Call

+ func (_c *Database_ListCollectionNames_Call) RunAndReturn(...) *Database_ListCollectionNames_Call

+ type Database_ListCollectionSpecifications_Call struct

+ func (_c *Database_ListCollectionSpecifications_Call) Return(_a0 []*mongo.CollectionSpecification, _a1 error) *Database_ListCollectionSpecifications_Call

+ func (_c *Database_ListCollectionSpecifications_Call) Run(run func(ctx context.Context, filter interface{}, ...)) *Database_ListCollectionSpecifications_Call

+ func (_c *Database_ListCollectionSpecifications_Call) RunAndReturn(...) *Database_ListCollectionSpecifications_Call

+ type Database_ListCollections_Call struct

+ func (_c *Database_ListCollections_Call) Return(_a0 mongoifc.Cursor, _a1 error) *Database_ListCollections_Call

+ func (_c *Database_ListCollections_Call) Run(run func(ctx context.Context, filter interface{}, ...)) *Database_ListCollections_Call

+ func (_c *Database_ListCollections_Call) RunAndReturn(...) *Database_ListCollections_Call

+ type Database_Name_Call struct

+ func (_c *Database_Name_Call) Return(_a0 string) *Database_Name_Call

+ func (_c *Database_Name_Call) Run(run func()) *Database_Name_Call

+ func (_c *Database_Name_Call) RunAndReturn(run func() string) *Database_Name_Call

+ type Database_ReadConcern_Call struct

+ func (_c *Database_ReadConcern_Call) Return(_a0 *readconcern.ReadConcern) *Database_ReadConcern_Call

+ func (_c *Database_ReadConcern_Call) Run(run func()) *Database_ReadConcern_Call

+ func (_c *Database_ReadConcern_Call) RunAndReturn(run func() *readconcern.ReadConcern) *Database_ReadConcern_Call

+ type Database_ReadPreference_Call struct

+ func (_c *Database_ReadPreference_Call) Return(_a0 *readpref.ReadPref) *Database_ReadPreference_Call

+ func (_c *Database_ReadPreference_Call) Run(run func()) *Database_ReadPreference_Call

+ func (_c *Database_ReadPreference_Call) RunAndReturn(run func() *readpref.ReadPref) *Database_ReadPreference_Call

+ type Database_RunCommandCursor_Call struct

+ func (_c *Database_RunCommandCursor_Call) Return(_a0 mongoifc.Cursor, _a1 error) *Database_RunCommandCursor_Call

+ func (_c *Database_RunCommandCursor_Call) Run(...) *Database_RunCommandCursor_Call

+ func (_c *Database_RunCommandCursor_Call) RunAndReturn(...) *Database_RunCommandCursor_Call

+ type Database_RunCommand_Call struct

+ func (_c *Database_RunCommand_Call) Return(_a0 mongoifc.SingleResult) *Database_RunCommand_Call

+ func (_c *Database_RunCommand_Call) Run(...) *Database_RunCommand_Call

+ func (_c *Database_RunCommand_Call) RunAndReturn(...) *Database_RunCommand_Call

+ type Database_Watch_Call struct

+ func (_c *Database_Watch_Call) Return(_a0 mongoifc.ChangeStream, _a1 error) *Database_Watch_Call

+ func (_c *Database_Watch_Call) Run(run func(ctx context.Context, pipeline interface{}, ...)) *Database_Watch_Call

+ func (_c *Database_Watch_Call) RunAndReturn(...) *Database_Watch_Call

+ type Database_WriteConcern_Call struct

+ func (_c *Database_WriteConcern_Call) Return(_a0 *writeconcern.WriteConcern) *Database_WriteConcern_Call

+ func (_c *Database_WriteConcern_Call) Run(run func()) *Database_WriteConcern_Call

+ func (_c *Database_WriteConcern_Call) RunAndReturn(run func() *writeconcern.WriteConcern) *Database_WriteConcern_Call

type IndexView

+ func (_m *IndexView) EXPECT() *IndexView_Expecter

+ type IndexView_CreateMany_Call struct

+ func (_c *IndexView_CreateMany_Call) Return(_a0 []string, _a1 error) *IndexView_CreateMany_Call

+ func (_c *IndexView_CreateMany_Call) Run(run func(ctx context.Context, models []mongo.IndexModel, ...)) *IndexView_CreateMany_Call

+ func (_c *IndexView_CreateMany_Call) RunAndReturn(...) *IndexView_CreateMany_Call

+ type IndexView_CreateOne_Call struct

+ func (_c *IndexView_CreateOne_Call) Return(_a0 string, _a1 error) *IndexView_CreateOne_Call

+ func (_c *IndexView_CreateOne_Call) Run(run func(ctx context.Context, model mongo.IndexModel, ...)) *IndexView_CreateOne_Call

+ func (_c *IndexView_CreateOne_Call) RunAndReturn(...) *IndexView_CreateOne_Call

+ type IndexView_DropAll_Call struct

+ func (_c *IndexView_DropAll_Call) Return(_a0 bson.Raw, _a1 error) *IndexView_DropAll_Call

+ func (_c *IndexView_DropAll_Call) Run(run func(ctx context.Context, opts ...*options.DropIndexesOptions)) *IndexView_DropAll_Call

+ func (_c *IndexView_DropAll_Call) RunAndReturn(run func(context.Context, ...*options.DropIndexesOptions) (bson.Raw, error)) *IndexView_DropAll_Call

+ type IndexView_DropOne_Call struct

+ func (_c *IndexView_DropOne_Call) Return(_a0 bson.Raw, _a1 error) *IndexView_DropOne_Call

+ func (_c *IndexView_DropOne_Call) Run(...) *IndexView_DropOne_Call

+ func (_c *IndexView_DropOne_Call) RunAndReturn(...) *IndexView_DropOne_Call

+ type IndexView_Expecter struct

+ func (_e *IndexView_Expecter) CreateMany(ctx interface{}, models interface{}, opts ...interface{}) *IndexView_CreateMany_Call

+ func (_e *IndexView_Expecter) CreateOne(ctx interface{}, model interface{}, opts ...interface{}) *IndexView_CreateOne_Call

+ func (_e *IndexView_Expecter) DropAll(ctx interface{}, opts ...interface{}) *IndexView_DropAll_Call

+ func (_e *IndexView_Expecter) DropOne(ctx interface{}, name interface{}, opts ...interface{}) *IndexView_DropOne_Call

+ func (_e *IndexView_Expecter) List(ctx interface{}, opts ...interface{}) *IndexView_List_Call

+ func (_e *IndexView_Expecter) ListSpecifications(ctx interface{}, opts ...interface{}) *IndexView_ListSpecifications_Call

+ type IndexView_ListSpecifications_Call struct

+ func (_c *IndexView_ListSpecifications_Call) Return(_a0 []*mongo.IndexSpecification, _a1 error) *IndexView_ListSpecifications_Call

+ func (_c *IndexView_ListSpecifications_Call) Run(run func(ctx context.Context, opts ...*options.ListIndexesOptions)) *IndexView_ListSpecifications_Call

+ func (_c *IndexView_ListSpecifications_Call) RunAndReturn(...) *IndexView_ListSpecifications_Call

+ type IndexView_List_Call struct

+ func (_c *IndexView_List_Call) Return(_a0 mongoifc.Cursor, _a1 error) *IndexView_List_Call

+ func (_c *IndexView_List_Call) Run(run func(ctx context.Context, opts ...*options.ListIndexesOptions)) *IndexView_List_Call

+ func (_c *IndexView_List_Call) RunAndReturn(...) *IndexView_List_Call

+ type SearchIndexView struct

+ func NewSearchIndexView(t interface{ ... }) *SearchIndexView

+ func (_m *SearchIndexView) CreateMany(ctx context.Context, models []mongo.SearchIndexModel, ...) ([]string, error)

+ func (_m *SearchIndexView) CreateOne(ctx context.Context, model mongo.SearchIndexModel, ...) (string, error)

+ func (_m *SearchIndexView) DropOne(ctx context.Context, name string, opts ...*options.DropSearchIndexOptions) error

+ func (_m *SearchIndexView) EXPECT() *SearchIndexView_Expecter

+ func (_m *SearchIndexView) List(ctx context.Context, searchIdxOpts *options.SearchIndexesOptions, ...) (mongoifc.Cursor, error)

+ func (_m *SearchIndexView) UpdateOne(ctx context.Context, name string, definition interface{}, ...) error

+ type SearchIndexView_CreateMany_Call struct

+ func (_c *SearchIndexView_CreateMany_Call) Return(_a0 []string, _a1 error) *SearchIndexView_CreateMany_Call

+ func (_c *SearchIndexView_CreateMany_Call) Run(run func(ctx context.Context, models []mongo.SearchIndexModel, ...)) *SearchIndexView_CreateMany_Call

+ func (_c *SearchIndexView_CreateMany_Call) RunAndReturn(run func(context.Context, []mongo.SearchIndexModel, ...) ([]string, error)) *SearchIndexView_CreateMany_Call

+ type SearchIndexView_CreateOne_Call struct

+ func (_c *SearchIndexView_CreateOne_Call) Return(_a0 string, _a1 error) *SearchIndexView_CreateOne_Call

+ func (_c *SearchIndexView_CreateOne_Call) Run(run func(ctx context.Context, model mongo.SearchIndexModel, ...)) *SearchIndexView_CreateOne_Call

+ func (_c *SearchIndexView_CreateOne_Call) RunAndReturn(run func(context.Context, mongo.SearchIndexModel, ...) (string, error)) *SearchIndexView_CreateOne_Call

+ type SearchIndexView_DropOne_Call struct

+ func (_c *SearchIndexView_DropOne_Call) Return(_a0 error) *SearchIndexView_DropOne_Call

+ func (_c *SearchIndexView_DropOne_Call) Run(...) *SearchIndexView_DropOne_Call

+ func (_c *SearchIndexView_DropOne_Call) RunAndReturn(run func(context.Context, string, ...*options.DropSearchIndexOptions) error) *SearchIndexView_DropOne_Call

+ type SearchIndexView_Expecter struct

+ func (_e *SearchIndexView_Expecter) CreateMany(ctx interface{}, models interface{}, opts ...interface{}) *SearchIndexView_CreateMany_Call

+ func (_e *SearchIndexView_Expecter) CreateOne(ctx interface{}, model interface{}, opts ...interface{}) *SearchIndexView_CreateOne_Call

+ func (_e *SearchIndexView_Expecter) DropOne(ctx interface{}, name interface{}, opts ...interface{}) *SearchIndexView_DropOne_Call

+ func (_e *SearchIndexView_Expecter) List(ctx interface{}, searchIdxOpts interface{}, opts ...interface{}) *SearchIndexView_List_Call

+ func (_e *SearchIndexView_Expecter) UpdateOne(ctx interface{}, name interface{}, definition interface{}, opts ...interface{}) *SearchIndexView_UpdateOne_Call

+ type SearchIndexView_List_Call struct

+ func (_c *SearchIndexView_List_Call) Return(_a0 mongoifc.Cursor, _a1 error) *SearchIndexView_List_Call

+ func (_c *SearchIndexView_List_Call) Run(...) *SearchIndexView_List_Call

+ func (_c *SearchIndexView_List_Call) RunAndReturn(...) *SearchIndexView_List_Call

+ type SearchIndexView_UpdateOne_Call struct

+ func (_c *SearchIndexView_UpdateOne_Call) Return(_a0 error) *SearchIndexView_UpdateOne_Call

+ func (_c *SearchIndexView_UpdateOne_Call) Run(run func(ctx context.Context, name string, definition interface{}, ...)) *SearchIndexView_UpdateOne_Call

+ func (_c *SearchIndexView_UpdateOne_Call) RunAndReturn(...) *SearchIndexView_UpdateOne_Call

type Session

+ func (_m *Session) EXPECT() *Session_Expecter

type SessionContext

+ func (_m *SessionContext) EXPECT() *SessionContext_Expecter

+ type SessionContext_AbortTransaction_Call struct

+ func (_c *SessionContext_AbortTransaction_Call) Return(_a0 error) *SessionContext_AbortTransaction_Call

+ func (_c *SessionContext_AbortTransaction_Call) Run(run func(ctx context.Context)) *SessionContext_AbortTransaction_Call

+ func (_c *SessionContext_AbortTransaction_Call) RunAndReturn(run func(context.Context) error) *SessionContext_AbortTransaction_Call

+ type SessionContext_AdvanceClusterTime_Call struct

+ func (_c *SessionContext_AdvanceClusterTime_Call) Return(_a0 error) *SessionContext_AdvanceClusterTime_Call

+ func (_c *SessionContext_AdvanceClusterTime_Call) Run(run func(_a0 bson.Raw)) *SessionContext_AdvanceClusterTime_Call

+ func (_c *SessionContext_AdvanceClusterTime_Call) RunAndReturn(run func(bson.Raw) error) *SessionContext_AdvanceClusterTime_Call

+ type SessionContext_AdvanceOperationTime_Call struct

+ func (_c *SessionContext_AdvanceOperationTime_Call) Return(_a0 error) *SessionContext_AdvanceOperationTime_Call

+ func (_c *SessionContext_AdvanceOperationTime_Call) Run(run func(_a0 *primitive.Timestamp)) *SessionContext_AdvanceOperationTime_Call

+ func (_c *SessionContext_AdvanceOperationTime_Call) RunAndReturn(run func(*primitive.Timestamp) error) *SessionContext_AdvanceOperationTime_Call

+ type SessionContext_Client_Call struct

+ func (_c *SessionContext_Client_Call) Return(_a0 mongoifc.Client) *SessionContext_Client_Call

+ func (_c *SessionContext_Client_Call) Run(run func()) *SessionContext_Client_Call

+ func (_c *SessionContext_Client_Call) RunAndReturn(run func() mongoifc.Client) *SessionContext_Client_Call

+ type SessionContext_ClusterTime_Call struct

+ func (_c *SessionContext_ClusterTime_Call) Return(_a0 bson.Raw) *SessionContext_ClusterTime_Call

+ func (_c *SessionContext_ClusterTime_Call) Run(run func()) *SessionContext_ClusterTime_Call

+ func (_c *SessionContext_ClusterTime_Call) RunAndReturn(run func() bson.Raw) *SessionContext_ClusterTime_Call

+ type SessionContext_CommitTransaction_Call struct

+ func (_c *SessionContext_CommitTransaction_Call) Return(_a0 error) *SessionContext_CommitTransaction_Call

+ func (_c *SessionContext_CommitTransaction_Call) Run(run func(ctx context.Context)) *SessionContext_CommitTransaction_Call

+ func (_c *SessionContext_CommitTransaction_Call) RunAndReturn(run func(context.Context) error) *SessionContext_CommitTransaction_Call

+ type SessionContext_Deadline_Call struct

+ func (_c *SessionContext_Deadline_Call) Return(deadline time.Time, ok bool) *SessionContext_Deadline_Call

+ func (_c *SessionContext_Deadline_Call) Run(run func()) *SessionContext_Deadline_Call

+ func (_c *SessionContext_Deadline_Call) RunAndReturn(run func() (time.Time, bool)) *SessionContext_Deadline_Call

+ type SessionContext_Done_Call struct

+ func (_c *SessionContext_Done_Call) Return(_a0 <-chan struct{}) *SessionContext_Done_Call

+ func (_c *SessionContext_Done_Call) Run(run func()) *SessionContext_Done_Call

+ func (_c *SessionContext_Done_Call) RunAndReturn(run func() <-chan struct{}) *SessionContext_Done_Call

+ type SessionContext_EndSession_Call struct

+ func (_c *SessionContext_EndSession_Call) Return() *SessionContext_EndSession_Call

+ func (_c *SessionContext_EndSession_Call) Run(run func(ctx context.Context)) *SessionContext_EndSession_Call

+ func (_c *SessionContext_EndSession_Call) RunAndReturn(run func(context.Context)) *SessionContext_EndSession_Call

+ type SessionContext_Err_Call struct

+ func (_c *SessionContext_Err_Call) Return(_a0 error) *SessionContext_Err_Call

+ func (_c *SessionContext_Err_Call) Run(run func()) *SessionContext_Err_Call

+ func (_c *SessionContext_Err_Call) RunAndReturn(run func() error) *SessionContext_Err_Call

+ type SessionContext_Expecter struct

+ func (_e *SessionContext_Expecter) AbortTransaction(ctx interface{}) *SessionContext_AbortTransaction_Call

+ func (_e *SessionContext_Expecter) AdvanceClusterTime(_a0 interface{}) *SessionContext_AdvanceClusterTime_Call

+ func (_e *SessionContext_Expecter) AdvanceOperationTime(_a0 interface{}) *SessionContext_AdvanceOperationTime_Call

+ func (_e *SessionContext_Expecter) Client() *SessionContext_Client_Call

+ func (_e *SessionContext_Expecter) ClusterTime() *SessionContext_ClusterTime_Call

+ func (_e *SessionContext_Expecter) CommitTransaction(ctx interface{}) *SessionContext_CommitTransaction_Call

+ func (_e *SessionContext_Expecter) Deadline() *SessionContext_Deadline_Call

+ func (_e *SessionContext_Expecter) Done() *SessionContext_Done_Call

+ func (_e *SessionContext_Expecter) EndSession(ctx interface{}) *SessionContext_EndSession_Call

+ func (_e *SessionContext_Expecter) Err() *SessionContext_Err_Call

+ func (_e *SessionContext_Expecter) ID() *SessionContext_ID_Call

+ func (_e *SessionContext_Expecter) OperationTime() *SessionContext_OperationTime_Call

+ func (_e *SessionContext_Expecter) StartTransaction(opts ...interface{}) *SessionContext_StartTransaction_Call

+ func (_e *SessionContext_Expecter) Value(key interface{}) *SessionContext_Value_Call

+ func (_e *SessionContext_Expecter) WithTransaction(ctx interface{}, fn interface{}, opts ...interface{}) *SessionContext_WithTransaction_Call

+ type SessionContext_ID_Call struct

+ func (_c *SessionContext_ID_Call) Return(_a0 bson.Raw) *SessionContext_ID_Call

+ func (_c *SessionContext_ID_Call) Run(run func()) *SessionContext_ID_Call

+ func (_c *SessionContext_ID_Call) RunAndReturn(run func() bson.Raw) *SessionContext_ID_Call

+ type SessionContext_OperationTime_Call struct

+ func (_c *SessionContext_OperationTime_Call) Return(_a0 *primitive.Timestamp) *SessionContext_OperationTime_Call

+ func (_c *SessionContext_OperationTime_Call) Run(run func()) *SessionContext_OperationTime_Call

+ func (_c *SessionContext_OperationTime_Call) RunAndReturn(run func() *primitive.Timestamp) *SessionContext_OperationTime_Call

+ type SessionContext_StartTransaction_Call struct

+ func (_c *SessionContext_StartTransaction_Call) Return(_a0 error) *SessionContext_StartTransaction_Call

+ func (_c *SessionContext_StartTransaction_Call) Run(run func(opts ...*options.TransactionOptions)) *SessionContext_StartTransaction_Call

+ func (_c *SessionContext_StartTransaction_Call) RunAndReturn(run func(...*options.TransactionOptions) error) *SessionContext_StartTransaction_Call

+ type SessionContext_Value_Call struct

+ func (_c *SessionContext_Value_Call) Return(_a0 interface{}) *SessionContext_Value_Call

+ func (_c *SessionContext_Value_Call) Run(run func(key interface{})) *SessionContext_Value_Call

+ func (_c *SessionContext_Value_Call) RunAndReturn(run func(interface{}) interface{}) *SessionContext_Value_Call

+ type SessionContext_WithTransaction_Call struct

+ func (_c *SessionContext_WithTransaction_Call) Return(_a0 interface{}, _a1 error) *SessionContext_WithTransaction_Call

+ func (_c *SessionContext_WithTransaction_Call) Run(...) *SessionContext_WithTransaction_Call

+ func (_c *SessionContext_WithTransaction_Call) RunAndReturn(...) *SessionContext_WithTransaction_Call

+ type Session_AbortTransaction_Call struct

+ func (_c *Session_AbortTransaction_Call) Return(_a0 error) *Session_AbortTransaction_Call

+ func (_c *Session_AbortTransaction_Call) Run(run func(ctx context.Context)) *Session_AbortTransaction_Call

+ func (_c *Session_AbortTransaction_Call) RunAndReturn(run func(context.Context) error) *Session_AbortTransaction_Call

+ type Session_AdvanceClusterTime_Call struct

+ func (_c *Session_AdvanceClusterTime_Call) Return(_a0 error) *Session_AdvanceClusterTime_Call

+ func (_c *Session_AdvanceClusterTime_Call) Run(run func(_a0 bson.Raw)) *Session_AdvanceClusterTime_Call

+ func (_c *Session_AdvanceClusterTime_Call) RunAndReturn(run func(bson.Raw) error) *Session_AdvanceClusterTime_Call

+ type Session_AdvanceOperationTime_Call struct

+ func (_c *Session_AdvanceOperationTime_Call) Return(_a0 error) *Session_AdvanceOperationTime_Call

+ func (_c *Session_AdvanceOperationTime_Call) Run(run func(_a0 *primitive.Timestamp)) *Session_AdvanceOperationTime_Call

+ func (_c *Session_AdvanceOperationTime_Call) RunAndReturn(run func(*primitive.Timestamp) error) *Session_AdvanceOperationTime_Call

+ type Session_Client_Call struct

+ func (_c *Session_Client_Call) Return(_a0 mongoifc.Client) *Session_Client_Call

+ func (_c *Session_Client_Call) Run(run func()) *Session_Client_Call

+ func (_c *Session_Client_Call) RunAndReturn(run func() mongoifc.Client) *Session_Client_Call

+ type Session_ClusterTime_Call struct

+ func (_c *Session_ClusterTime_Call) Return(_a0 bson.Raw) *Session_ClusterTime_Call

+ func (_c *Session_ClusterTime_Call) Run(run func()) *Session_ClusterTime_Call

+ func (_c *Session_ClusterTime_Call) RunAndReturn(run func() bson.Raw) *Session_ClusterTime_Call

+ type Session_CommitTransaction_Call struct

+ func (_c *Session_CommitTransaction_Call) Return(_a0 error) *Session_CommitTransaction_Call

+ func (_c *Session_CommitTransaction_Call) Run(run func(ctx context.Context)) *Session_CommitTransaction_Call

+ func (_c *Session_CommitTransaction_Call) RunAndReturn(run func(context.Context) error) *Session_CommitTransaction_Call

+ type Session_EndSession_Call struct

+ func (_c *Session_EndSession_Call) Return() *Session_EndSession_Call

+ func (_c *Session_EndSession_Call) Run(run func(ctx context.Context)) *Session_EndSession_Call

+ func (_c *Session_EndSession_Call) RunAndReturn(run func(context.Context)) *Session_EndSession_Call

+ type Session_Expecter struct

+ func (_e *Session_Expecter) AbortTransaction(ctx interface{}) *Session_AbortTransaction_Call

+ func (_e *Session_Expecter) AdvanceClusterTime(_a0 interface{}) *Session_AdvanceClusterTime_Call

+ func (_e *Session_Expecter) AdvanceOperationTime(_a0 interface{}) *Session_AdvanceOperationTime_Call

+ func (_e *Session_Expecter) Client() *Session_Client_Call

+ func (_e *Session_Expecter) ClusterTime() *Session_ClusterTime_Call

+ func (_e *Session_Expecter) CommitTransaction(ctx interface{}) *Session_CommitTransaction_Call

+ func (_e *Session_Expecter) EndSession(ctx interface{}) *Session_EndSession_Call

+ func (_e *Session_Expecter) ID() *Session_ID_Call

+ func (_e *Session_Expecter) OperationTime() *Session_OperationTime_Call

+ func (_e *Session_Expecter) StartTransaction(opts ...interface{}) *Session_StartTransaction_Call

+ func (_e *Session_Expecter) WithTransaction(ctx interface{}, fn interface{}, opts ...interface{}) *Session_WithTransaction_Call

+ type Session_ID_Call struct

+ func (_c *Session_ID_Call) Return(_a0 bson.Raw) *Session_ID_Call

+ func (_c *Session_ID_Call) Run(run func()) *Session_ID_Call

+ func (_c *Session_ID_Call) RunAndReturn(run func() bson.Raw) *Session_ID_Call

+ type Session_OperationTime_Call struct

+ func (_c *Session_OperationTime_Call) Return(_a0 *primitive.Timestamp) *Session_OperationTime_Call

+ func (_c *Session_OperationTime_Call) Run(run func()) *Session_OperationTime_Call

+ func (_c *Session_OperationTime_Call) RunAndReturn(run func() *primitive.Timestamp) *Session_OperationTime_Call

+ type Session_StartTransaction_Call struct

+ func (_c *Session_StartTransaction_Call) Return(_a0 error) *Session_StartTransaction_Call

+ func (_c *Session_StartTransaction_Call) Run(run func(opts ...*options.TransactionOptions)) *Session_StartTransaction_Call

+ func (_c *Session_StartTransaction_Call) RunAndReturn(run func(...*options.TransactionOptions) error) *Session_StartTransaction_Call

+ type Session_WithTransaction_Call struct

+ func (_c *Session_WithTransaction_Call) Return(_a0 interface{}, _a1 error) *Session_WithTransaction_Call

+ func (_c *Session_WithTransaction_Call) Run(...) *Session_WithTransaction_Call

+ func (_c *Session_WithTransaction_Call) RunAndReturn(...) *Session_WithTransaction_Call

type SingleResult

+ func (_m *SingleResult) EXPECT() *SingleResult_Expecter

+ func (_m *SingleResult) Raw() (bson.Raw, error)

+ type SingleResult_DecodeBytes_Call struct

+ func (_c *SingleResult_DecodeBytes_Call) Return(_a0 bson.Raw, _a1 error) *SingleResult_DecodeBytes_Call

+ func (_c *SingleResult_DecodeBytes_Call) Run(run func()) *SingleResult_DecodeBytes_Call

+ func (_c *SingleResult_DecodeBytes_Call) RunAndReturn(run func() (bson.Raw, error)) *SingleResult_DecodeBytes_Call

+ type SingleResult_Decode_Call struct

+ func (_c *SingleResult_Decode_Call) Return(_a0 error) *SingleResult_Decode_Call

+ func (_c *SingleResult_Decode_Call) Run(run func(v interface{})) *SingleResult_Decode_Call

+ func (_c *SingleResult_Decode_Call) RunAndReturn(run func(interface{}) error) *SingleResult_Decode_Call

+ type SingleResult_Err_Call struct

+ func (_c *SingleResult_Err_Call) Return(_a0 error) *SingleResult_Err_Call

+ func (_c *SingleResult_Err_Call) Run(run func()) *SingleResult_Err_Call

+ func (_c *SingleResult_Err_Call) RunAndReturn(run func() error) *SingleResult_Err_Call

+ type SingleResult_Expecter struct

+ func (_e *SingleResult_Expecter) Decode(v interface{}) *SingleResult_Decode_Call

+ func (_e *SingleResult_Expecter) DecodeBytes() *SingleResult_DecodeBytes_Call

+ func (_e *SingleResult_Expecter) Err() *SingleResult_Err_Call

+ func (_e *SingleResult_Expecter) Raw() *SingleResult_Raw_Call

+ type SingleResult_Raw_Call struct

+ func (_c *SingleResult_Raw_Call) Return(_a0 bson.Raw, _a1 error) *SingleResult_Raw_Call

+ func (_c *SingleResult_Raw_Call) Run(run func()) *SingleResult_Raw_Call

+ func (_c *SingleResult_Raw_Call) RunAndReturn(run func() (bson.Raw, error)) *SingleResult_Raw_Call

v1.12.1

Aug 7, 2023

v1.12.0

Jul 9, 2023

v1.11.7

Jun 13, 2023

v1.11.6

May 10, 2023

v1.11.4

Apr 11, 2023

v1.11.3

Mar 20, 2023

v1.11.2

Feb 23, 2023

v1.11.1

Feb 5, 2023

Changes in this version

type Client

+ func (_m *Client) Timeout() *time.Duration

v1.10.2

Sep 19, 2022

v1.10.1

Sep 19, 2022

v1.9.1

May 9, 2022

Changes in this version

type ChangeStream

+ func NewChangeStream(t testing.TB) *ChangeStream

type Client

+ func NewClient(t testing.TB) *Client

type Collection

+ func NewCollection(t testing.TB) *Collection

type Cursor

+ func NewCursor(t testing.TB) *Cursor

type Database

+ func NewDatabase(t testing.TB) *Database

type IndexView

+ func NewIndexView(t testing.TB) *IndexView

type Session

+ func NewSession(t testing.TB) *Session

type SessionContext

+ func NewSessionContext(t testing.TB) *SessionContext

type SingleResult

+ func NewSingleResult(t testing.TB) *SingleResult

v1.9.0

Apr 9, 2022

v1.8.4

Mar 7, 2022

v1.8.3

Feb 18, 2022

v1.8.2

Jan 5, 2022

v1.8.1

Dec 12, 2021

v1.8.0

Dec 12, 2021

v1.0.0

Nov 27, 2021

Changes in this version

+ type SessionContext struct

+ func (_m *SessionContext) AbortTransaction(ctx context.Context) error

+ func (_m *SessionContext) AdvanceClusterTime(_a0 bson.Raw) error

+ func (_m *SessionContext) AdvanceOperationTime(_a0 *primitive.Timestamp) error

+ func (_m *SessionContext) Client() mongoifc.Client

+ func (_m *SessionContext) ClusterTime() bson.Raw

+ func (_m *SessionContext) CommitTransaction(ctx context.Context) error

+ func (_m *SessionContext) Deadline() (time.Time, bool)

+ func (_m *SessionContext) Done() <-chan struct{}

+ func (_m *SessionContext) EndSession(ctx context.Context)

+ func (_m *SessionContext) Err() error

+ func (_m *SessionContext) ID() bson.Raw

+ func (_m *SessionContext) OperationTime() *primitive.Timestamp

+ func (_m *SessionContext) StartTransaction(opts ...*options.TransactionOptions) error

+ func (_m *SessionContext) Value(key interface{}) interface{}

+ func (_m *SessionContext) WithTransaction(ctx context.Context, fn func(mongoifc.SessionContext) (interface{}, error), ...) (interface{}, error)

v0

v0.4.0

Nov 25, 2021

v0.3.0

Nov 25, 2021

Changes in this version

+ type ChangeStream struct

+ func (_m *ChangeStream) Close(ctx context.Context) error

+ func (_m *ChangeStream) Current() bson.Raw

+ func (_m *ChangeStream) Decode(val interface{}) error

+ func (_m *ChangeStream) Err() error

+ func (_m *ChangeStream) ID() int64

+ func (_m *ChangeStream) Next(ctx context.Context) bool

+ func (_m *ChangeStream) ResumeToken() bson.Raw

+ func (_m *ChangeStream) TryNext(ctx context.Context) bool

+ func (_m *ChangeStream) WrappedChangeStream() *mongo.ChangeStream

+ type Client struct

+ func (_m *Client) Connect(ctx context.Context) error

+ func (_m *Client) Database(name string, opts ...*options.DatabaseOptions) mongoifc.Database

+ func (_m *Client) Disconnect(ctx context.Context) error

+ func (_m *Client) ListDatabaseNames(ctx context.Context, filter interface{}, opts ...*options.ListDatabasesOptions) ([]string, error)

+ func (_m *Client) ListDatabases(ctx context.Context, filter interface{}, opts ...*options.ListDatabasesOptions) (mongo.ListDatabasesResult, error)

+ func (_m *Client) NumberSessionsInProgress() int

+ func (_m *Client) Ping(ctx context.Context, rp *readpref.ReadPref) error

+ func (_m *Client) StartSession(opts ...*options.SessionOptions) (mongoifc.Session, error)

+ func (_m *Client) UseSession(ctx context.Context, fn func(mongo.SessionContext) error) error

+ func (_m *Client) UseSessionWithOptions(ctx context.Context, opts *options.SessionOptions, ...) error

+ func (_m *Client) Watch(ctx context.Context, pipeline interface{}, ...) (mongoifc.ChangeStream, error)

+ func (_m *Client) WrappedClient() *mongo.Client

+ type Collection struct

+ func (_m *Collection) Aggregate(ctx context.Context, pipeline interface{}, opts ...*options.AggregateOptions) (mongoifc.Cursor, error)

+ func (_m *Collection) BulkWrite(ctx context.Context, models []mongo.WriteModel, ...) (*mongo.BulkWriteResult, error)

+ func (_m *Collection) Clone(opts ...*options.CollectionOptions) (mongoifc.Collection, error)

+ func (_m *Collection) CountDocuments(ctx context.Context, filter interface{}, opts ...*options.CountOptions) (int64, error)

+ func (_m *Collection) Database() mongoifc.Database

+ func (_m *Collection) DeleteMany(ctx context.Context, filter interface{}, opts ...*options.DeleteOptions) (*mongo.DeleteResult, error)

+ func (_m *Collection) DeleteOne(ctx context.Context, filter interface{}, opts ...*options.DeleteOptions) (*mongo.DeleteResult, error)

+ func (_m *Collection) Distinct(ctx context.Context, fieldName string, filter interface{}, ...) ([]interface{}, error)

+ func (_m *Collection) Drop(ctx context.Context) error

+ func (_m *Collection) EstimatedDocumentCount(ctx context.Context, opts ...*options.EstimatedDocumentCountOptions) (int64, error)

+ func (_m *Collection) Find(ctx context.Context, filter interface{}, opts ...*options.FindOptions) (mongoifc.Cursor, error)

+ func (_m *Collection) FindOne(ctx context.Context, filter interface{}, opts ...*options.FindOneOptions) mongoifc.SingleResult

+ func (_m *Collection) FindOneAndDelete(ctx context.Context, filter interface{}, ...) mongoifc.SingleResult

+ func (_m *Collection) FindOneAndReplace(ctx context.Context, filter interface{}, replacement interface{}, ...) mongoifc.SingleResult

+ func (_m *Collection) FindOneAndUpdate(ctx context.Context, filter interface{}, update interface{}, ...) mongoifc.SingleResult

+ func (_m *Collection) Indexes() mongoifc.IndexView

+ func (_m *Collection) InsertMany(ctx context.Context, documents []interface{}, ...) (*mongo.InsertManyResult, error)

+ func (_m *Collection) InsertOne(ctx context.Context, document interface{}, opts ...*options.InsertOneOptions) (*mongo.InsertOneResult, error)

+ func (_m *Collection) Name() string

+ func (_m *Collection) ReplaceOne(ctx context.Context, filter interface{}, replacement interface{}, ...) (*mongo.UpdateResult, error)

+ func (_m *Collection) UpdateByID(ctx context.Context, id interface{}, update interface{}, ...) (*mongo.UpdateResult, error)

+ func (_m *Collection) UpdateMany(ctx context.Context, filter interface{}, update interface{}, ...) (*mongo.UpdateResult, error)

+ func (_m *Collection) UpdateOne(ctx context.Context, filter interface{}, update interface{}, ...) (*mongo.UpdateResult, error)

+ func (_m *Collection) Watch(ctx context.Context, pipeline interface{}, ...) (mongoifc.ChangeStream, error)

+ func (_m *Collection) WrappedCollection() *mongo.Collection

+ type Cursor struct

+ func (_m *Cursor) All(ctx context.Context, results interface{}) error

+ func (_m *Cursor) Close(ctx context.Context) error

+ func (_m *Cursor) Current() bson.Raw

+ func (_m *Cursor) Decode(val interface{}) error

+ func (_m *Cursor) Err() error

+ func (_m *Cursor) ID() int64

+ func (_m *Cursor) Next(ctx context.Context) bool

+ func (_m *Cursor) RemainingBatchLength() int

+ func (_m *Cursor) TryNext(ctx context.Context) bool

+ func (_m *Cursor) WrappedCursor() *mongo.Cursor

+ type Database struct

+ func (_m *Database) Aggregate(ctx context.Context, pipeline interface{}, opts ...*options.AggregateOptions) (mongoifc.Cursor, error)

+ func (_m *Database) Client() mongoifc.Client

+ func (_m *Database) Collection(name string, opts ...*options.CollectionOptions) mongoifc.Collection

+ func (_m *Database) CreateCollection(ctx context.Context, name string, opts ...*options.CreateCollectionOptions) error

+ func (_m *Database) CreateView(ctx context.Context, viewName string, viewOn string, pipeline interface{}, ...) error

+ func (_m *Database) Drop(ctx context.Context) error

+ func (_m *Database) ListCollectionNames(ctx context.Context, filter interface{}, ...) ([]string, error)

+ func (_m *Database) ListCollectionSpecifications(ctx context.Context, filter interface{}, ...) ([]*mongo.CollectionSpecification, error)

+ func (_m *Database) ListCollections(ctx context.Context, filter interface{}, ...) (mongoifc.Cursor, error)

+ func (_m *Database) Name() string

+ func (_m *Database) ReadConcern() *readconcern.ReadConcern

+ func (_m *Database) ReadPreference() *readpref.ReadPref

+ func (_m *Database) RunCommand(ctx context.Context, runCommand interface{}, opts ...*options.RunCmdOptions) mongoifc.SingleResult

+ func (_m *Database) RunCommandCursor(ctx context.Context, runCommand interface{}, opts ...*options.RunCmdOptions) (mongoifc.Cursor, error)

+ func (_m *Database) Watch(ctx context.Context, pipeline interface{}, ...) (mongoifc.ChangeStream, error)

+ func (_m *Database) WrappedDatabase() *mongo.Database

+ func (_m *Database) WriteConcern() *writeconcern.WriteConcern

+ type IndexView struct

+ func (_m *IndexView) CreateMany(ctx context.Context, models []mongo.IndexModel, ...) ([]string, error)

+ func (_m *IndexView) CreateOne(ctx context.Context, model mongo.IndexModel, ...) (string, error)

+ func (_m *IndexView) DropAll(ctx context.Context, opts ...*options.DropIndexesOptions) (bson.Raw, error)

+ func (_m *IndexView) DropOne(ctx context.Context, name string, opts ...*options.DropIndexesOptions) (bson.Raw, error)

+ func (_m *IndexView) List(ctx context.Context, opts ...*options.ListIndexesOptions) (mongoifc.Cursor, error)

+ func (_m *IndexView) ListSpecifications(ctx context.Context, opts ...*options.ListIndexesOptions) ([]*mongo.IndexSpecification, error)

+ func (_m *IndexView) WrappedIndexView() *mongo.IndexView

+ type Session struct

+ func (_m *Session) AbortTransaction(ctx context.Context) error

+ func (_m *Session) AdvanceClusterTime(_a0 bson.Raw) error

+ func (_m *Session) AdvanceOperationTime(_a0 *primitive.Timestamp) error

+ func (_m *Session) Client() mongoifc.Client

+ func (_m *Session) ClusterTime() bson.Raw

+ func (_m *Session) CommitTransaction(ctx context.Context) error

+ func (_m *Session) EndSession(ctx context.Context)

+ func (_m *Session) ID() bson.Raw

+ func (_m *Session) OperationTime() *primitive.Timestamp

+ func (_m *Session) StartTransaction(opts ...*options.TransactionOptions) error

+ func (_m *Session) WithTransaction(ctx context.Context, fn func(mongo.SessionContext) (interface{}, error), ...) (interface{}, error)

+ func (_m *Session) WrappedSession() mongo.Session

+ type SingleResult struct

+ func (_m *SingleResult) Decode(v interface{}) error

+ func (_m *SingleResult) DecodeBytes() (bson.Raw, error)

+ func (_m *SingleResult) Err() error

+ func (_m *SingleResult) WrappedSingleResult() *mongo.SingleResult

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL