Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📄 causal_consistency_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "testing" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/mongo/readconcern" ) // set of operations that support read concerns taken from read/write concern spec. // the spec also lists "count" but that has been deprecated and removed from the driver. var readConcernOperations = map[string]struct{}{ "Aggregate": {}, "Distinct": {}, "Find": {}, } func TestCausalConsistency_Supported(t testing.T) { mt := mtest.New(t, mtest.NewOptions().MinServerVersion("3.6").Topologies(mtest.ReplicaSet, mtest.Sharded).CreateClient(false)) mt.Run("operation time nil", func(mt mtest.T) { // when a ClientSession is first created, the operation time is nil sess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) defer sess.EndSession(context.Background()) assert.Nil(mt, sess.OperationTime(), "expected nil operation time, got %v", sess.OperationTime()) }) mt.Run("no cluster time on first command", func(mt mtest.T) { // first read in a causally consistent session must not send afterClusterTime to the server ccOpts := options.Session().SetCausalConsistency(true) _ = mt.Client.UseSessionWithOptions(context.Background(), ccOpts, func(sc mongo.SessionContext) error { _, _ = mt.Coll.Find(sc, bson.D{}) return nil }) evt := mt.GetStartedEvent() assert.Equal(mt, "find", evt.CommandName, "expected 'find' event, got '%v'", evt.CommandName) checkOperationTime(mt, evt.Command, false) }) mt.Run("operation time updated", func(mt mtest.T) { // first read or write on a ClientSession should update the operationTime of the session, even if there is an error sess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) defer sess.EndSession(context.Background()) _ = mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { _, _ = mt.Coll.Find(sc, bson.D{}) return nil }) evt := mt.GetSucceededEvent() assert.Equal(mt, "find", evt.CommandName, "expected 'find' event, got '%v'", evt.CommandName) serverT, serverI := evt.Reply.Lookup("operationTime").Timestamp() serverTs := &primitive.Timestamp{serverT, serverI} sessionTs := sess.OperationTime() assert.NotNil(mt, sessionTs, "expected session operation time, got nil") assert.True(mt, serverTs.Equal(sessionTs), "expected operation time %v, got %v", serverTs, sessionTs) }) mt.RunOpts("operation time sent", noClientOpts, func(mt mtest.T) { // findOne followed by another read operation should include operationTime returned by server for the first // operation as the afterClusterTime field of the second operation for _, sf := range createFunctionsSlice() { // skip write operations if _, ok := readConcernOperations[sf.fnName]; !ok { continue } mt.Run(sf.name, func(mt mtest.T) { sess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) defer sess.EndSession(context.Background()) _ = mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { _ = mt.Coll.FindOne(sc, bson.D{}) return nil }) currOptime := sess.OperationTime() assert.NotNil(mt, currOptime, "expected session operation time, got nil") mt.ClearEvents() _ = sf.execute(mt, sess) _, sentOptime := getReadConcernFields(mt, mt.GetStartedEvent().Command) assert.NotNil(mt, sentOptime, "expected operation time on command, got nil") assert.True(mt, currOptime.Equal(sentOptime), "expected operation time %v, got %v", currOptime, sentOptime) }) } }) mt.RunOpts("write then read", noClientOpts, func(mt mtest.T) { // any write operation followed by a findOne should include operationTime of the first operation as afterClusterTime // in the second operation for _, sf := range createFunctionsSlice() { // skip read operations if _, ok := readConcernOperations[sf.fnName]; ok { continue } mt.Run(sf.name, func(mt mtest.T) { sess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) defer sess.EndSession(context.Background()) _ = sf.execute(mt, sess) currOptime := sess.OperationTime() assert.NotNil(mt, currOptime, "expected session operation time, got nil") mt.ClearEvents() _ = mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { _ = mt.Coll.FindOne(sc, bson.D{}) return nil }) _, sentOptime := getReadConcernFields(mt, mt.GetStartedEvent().Command) assert.NotNil(mt, sentOptime, "expected operation time on command, got nil") assert.True(mt, currOptime.Equal(sentOptime), "expected operation time %v, got %v", currOptime, sentOptime) }) } }) mt.Run("non-consistent read", func(mt mtest.T) { // a read operation in a non causally-consistent session should not include afterClusterTime sessOpts := options.Session().SetCausalConsistency(false) _ = mt.Client.UseSessionWithOptions(context.Background(), sessOpts, func(sc mongo.SessionContext) error { _, _ = mt.Coll.Find(sc, bson.D{}) mt.ClearEvents() _, _ = mt.Coll.Find(sc, bson.D{}) return nil }) evt := mt.GetStartedEvent() assert.Equal(mt, "find", evt.CommandName, "expected 'find' command, got '%v'", evt.CommandName) checkOperationTime(mt, evt.Command, false) }) mt.Run("default read concern", func(mt mtest.T) { // when using the default server read concern, the readConcern parameter in the command sent to the server should // not include a level field sess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) defer sess.EndSession(context.Background()) _ = mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { _ = mt.Coll.FindOne(sc, bson.D{}) return nil }) currOptime := sess.OperationTime() mt.ClearEvents() _ = mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { _ = mt.Coll.FindOne(sc, bson.D{}) return nil }) level, sentOptime := getReadConcernFields(mt, mt.GetStartedEvent().Command) assert.Equal(mt, "", level, "expected command to not have read concern level, got %s", level) assert.NotNil(mt, sentOptime, "expected operation time on command, got nil") assert.True(mt, currOptime.Equal(sentOptime), "expected operation time %v, got %v", currOptime, sentOptime) }) localRcOpts := options.Client().SetReadConcern(readconcern.Local()) mt.RunOpts("custom read concern", mtest.NewOptions().ClientOptions(localRcOpts), func(mt mtest.T) { sess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) defer sess.EndSession(context.Background()) _ = mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { _ = mt.Coll.FindOne(sc, bson.D{}) return nil }) currOptime := sess.OperationTime() mt.ClearEvents() _ = mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { _ = mt.Coll.FindOne(sc, bson.D{}) return nil }) level, sentOptime := getReadConcernFields(mt, mt.GetStartedEvent().Command) assert.Equal(mt, "local", level, "expected read concern level 'local', got %s", level) assert.NotNil(mt, sentOptime, "expected operation time on command, got nil") assert.True(mt, currOptime.Equal(sentOptime), "expected operation time %v, got %v", currOptime, sentOptime) }) mt.Run("clusterTime included", func(mt mtest.T) { // $clusterTime should be included in commands if the deployment supports cluster times _ = mt.Coll.FindOne(context.Background(), bson.D{}) evt := mt.GetStartedEvent() assert.Equal(mt, "find", evt.CommandName, "expected command 'find', got '%v'", evt.CommandName) _, err := evt.Command.LookupErr("$clusterTime") assert.Nil(mt, err, "expected $clusterTime in command, got nil") }) } func TestCausalConsistency_NotSupported(t testing.T) { // use RunOnBlock instead of mtest.NewOptions().MaxServerVersion("3.4").Topologies(mtest.Single) because // these tests should be run on servers <= 3.4 OR standalones rob := []mtest.RunOnBlock{ {MaxServerVersion: "3.4"}, {Topology: []mtest.TopologyKind{mtest.Single}}, } mt := mtest.New(t, mtest.NewOptions().RunOn(rob...).CreateClient(false)) mt.Run("afterClusterTime not included", func(mt mtest.T) { // a read in a causally consistent session does not include afterClusterTime in a deployment that does not // support cluster times sessOpts := options.Session().SetCausalConsistency(true) _ = mt.Client.UseSessionWithOptions(context.Background(), sessOpts, func(sc mongo.SessionContext) error { _, _ = mt.Coll.Find(sc, bson.D{}) return nil }) evt := mt.GetStartedEvent() assert.Equal(mt, "find", evt.CommandName, "expected command 'find', got '%v'", evt.CommandName) checkOperationTime(mt, evt.Command, false) }) mt.Run("clusterTime not included", func(mt mtest.T) { // $clusterTime should not be included in commands if the deployment does not support cluster times _ = mt.Coll.FindOne(context.Background(), bson.D{}) evt := mt.GetStartedEvent() assert.Equal(mt, "find", evt.CommandName, "expected command 'find', got '%v'", evt.CommandName) _, err := evt.Command.LookupErr("$clusterTime") assert.NotNil(mt, err, "expected $clusterTime to not be sent, but was") }) } func checkOperationTime(mt mtest.T, cmd bson.Raw, shouldInclude bool) { mt.Helper() _, optime := getReadConcernFields(mt, cmd) if shouldInclude { assert.NotNil(mt, optime, "expected operation time, got nil") return } assert.Nil(mt, optime, "did not expect operation time, got %v", optime) } func getReadConcernFields(mt mtest.T, cmd bson.Raw) (string, primitive.Timestamp) { mt.Helper() rc, err := cmd.LookupErr("readConcern") if err != nil { return "", nil } rcDoc := rc.Document() var level string var clusterTime primitive.Timestamp if levelVal, err := rcDoc.LookupErr("level"); err == nil { level = levelVal.StringValue() } if ctVal, err := rcDoc.LookupErr("afterClusterTime"); err == nil { t, i := ctVal.Timestamp() clusterTime = &primitive.Timestamp{t, i} } return level, clusterTime }	10.48 KB	2025-05-25 12:27
📄 change_stream_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "strings" "sync" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/eventtest" "go.mongodb.org/mongo-driver/internal/require" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" ) type resumeType int type streamType int const ( minChangeStreamVersion = "3.6.0" minPbrtVersion = "4.0.7" minStartAfterVersion = "4.1.1" startAfter resumeType = iota resumeAfter operationTime client streamType = iota database collection errorInterrupted int32 = 11601 errorHostUnreachable int32 = 6 resumableChangeStreamError = "ResumableChangeStreamError" ) func TestChangeStream_Standalone(t testing.T) { mtOpts := mtest.NewOptions().MinServerVersion(minChangeStreamVersion).CreateClient(false).Topologies(mtest.Single) mt := mtest.New(t, mtOpts) mt.Run("no custom standalone error", func(mt mtest.T) { _, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) _, ok := err.(mongo.CommandError) assert.True(mt, ok, "expected error type %T, got %T", mongo.CommandError{}, err) }) } func TestChangeStream_ReplicaSet(t testing.T) { mtOpts := mtest.NewOptions().MinServerVersion(minChangeStreamVersion).CreateClient(false).Topologies(mtest.ReplicaSet) mt := mtest.New(t, mtOpts) mt.Run("first stage is $changeStream", func(mt mtest.T) { // first stage in the aggregate pipeline must be $changeStream cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) started := mt.GetStartedEvent() assert.NotNil(mt, started, "expected started event for aggregate, got nil") // pipeline is array of documents. first value of first element in array is the first stage document firstStage := started.Command.Lookup("pipeline").Array().Index(0).Value().Document() elems, _ := firstStage.Elements() assert.Equal(mt, 1, len(elems), "expected first stage document to have 1 element, got %v", len(elems)) firstKey := elems[0].Key() want := "$changeStream" assert.Equal(mt, want, firstKey, "expected first stage to be %v, got %v", want, firstKey) }) mt.Run("track resume token", func(mt mtest.T) { // ChangeStream must continuously track the last seen resumeToken cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) generateEvents(mt, 1) assert.True(mt, cs.Next(context.Background()), "expected next to return true, got false") assert.NotNil(mt, cs.ResumeToken(), "expected resume token, got nil") }) mt.RunOpts("resume token updated on empty batch", mtest.NewOptions().MinServerVersion("4.0.7"), func(mt mtest.T) { // The resume token is updated when an empty batch is returned using the server's post batch resume token. cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) // cause an event to occur so the resume token is updated generateEvents(mt, 1) assert.True(mt, cs.Next(context.Background()), "expected next to return true, got false") firstToken := cs.ResumeToken() // cause an event on a different collection than the one being watched so the server's PBRT is updated diffColl := mt.CreateCollection(mtest.Collection{Name: "diffCollUpdatePbrt"}, false) _, err = diffColl.InsertOne(context.Background(), bson.D{{"x", 1}}) assert.Nil(mt, err, "InsertOne error: %v", err) // verify that the resume token is updated using the PBRT from an empty batch mt.ClearEvents() assert.False(mt, cs.TryNext(context.Background()), "unexpected event document: %v", cs.Current) assert.Nil(mt, cs.Err(), "change stream error getting new batch: %v", cs.Err()) newToken := cs.ResumeToken() assert.NotEqual(mt, newToken, firstToken, "resume token was not updated after an empty batch was returned") evt := mt.GetSucceededEvent() assert.Equal(mt, "getMore", evt.CommandName, "expected event for 'getMore', got '%v'", evt.CommandName) getMorePbrt := evt.Reply.Lookup("cursor", "postBatchResumeToken").Document() assert.Equal(mt, newToken, getMorePbrt, "expected resume token %v, got %v", getMorePbrt, newToken) }) mt.Run("missing resume token", func(mt mtest.T) { // ChangeStream will throw an exception if the server response is missing the resume token projectDoc := bson.D{ {"$project", bson.D{ {"_id", 0}, }}, } cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{projectDoc}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) generateEvents(mt, 2) assert.False(mt, cs.Next(context.Background()), "expected Next to return false, got true") assert.NotNil(mt, cs.Err(), "expected error, got nil") }) mt.RunOpts("resume once", mtest.NewOptions().ClientType(mtest.Mock), func(mt mtest.T) { // ChangeStream will automatically resume one time on a resumable error // aggregateRes: create change stream with ID 1 and a batch of size 1 so the resume token will be recorded // failureGetMoreRes: resumable error // killCursorsRes: success // resumedAggregateRes: create new change stream with ID 2 and a batch of size 1 so the resume token will be // updated ns := mt.Coll.Database().Name() + "." + mt.Coll.Name() aggregateRes := mtest.CreateCursorResponse(1, ns, mtest.FirstBatch, bson.D{ {"_id", bson.D{{"first", "resume token"}}}, }) failureGetMoreRes := mtest.CreateCommandErrorResponse(mtest.CommandError{ Code: errorHostUnreachable, Name: "foo", Message: "bar", Labels: []string{resumableChangeStreamError}, }) killCursorsRes := mtest.CreateSuccessResponse() newResumeToken := bson.D{{"second", "resume token"}} resumedAggregateRes := mtest.CreateCursorResponse(2, ns, mtest.FirstBatch, bson.D{ {"_id", newResumeToken}, }) mt.AddMockResponses( aggregateRes, failureGetMoreRes, killCursorsRes, resumedAggregateRes, ) cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) // Consume the first document assert.True(mt, cs.Next(context.Background()), "expected Next to return true, got false") // Clear existing events and expect a resume attempt to happen. mt.ClearEvents() assert.True(mt, cs.Next(context.Background()), "expected Next to return true, got false") // Next should cause getMore, killCursors, and aggregate to run assert.NotNil(mt, mt.GetStartedEvent(), "expected getMore event, got nil") assert.NotNil(mt, mt.GetStartedEvent(), "expected killCursors event, got nil") aggEvent := mt.GetStartedEvent() assert.NotNil(mt, aggEvent, "expected aggregate event, got nil") assert.Equal(mt, "aggregate", aggEvent.CommandName, "expected command name 'aggregate', got '%v'", aggEvent.CommandName) // Assert that the change stream has updated it's ID and resume token. assert.Equal(mt, cs.ID(), int64(2), "expected change stream ID to be 2, got %d", cs.ID()) newResumeTokenRaw, err := bson.Marshal(newResumeToken) assert.Nil(mt, err, "Marshal error: %v", err) comparisonErr := compareDocs(mt, newResumeTokenRaw, cs.ResumeToken()) assert.Nil(mt, comparisonErr, "expected resume token %s, got %s", newResumeTokenRaw, cs.ResumeToken()) }) mt.RunOpts("no resume for aggregate errors", mtest.NewOptions().ClientType(mtest.Mock), func(mt mtest.T) { // ChangeStream will not attempt to resume on any error encountered while executing an aggregate command // aggregate response: empty batch but valid cursor ID // getMore response: resumable error // killCursors response: success // resumed aggregate response: resumable error ns := mt.Coll.Database().Name() + "." + mt.Coll.Name() aggRes := mtest.CreateCursorResponse(1, ns, mtest.FirstBatch) getMoreRes := mtest.CreateCommandErrorResponse(mtest.CommandError{ Code: errorHostUnreachable, Name: "foo", Message: "bar", Labels: []string{resumableChangeStreamError}, }) killCursorsRes := mtest.CreateSuccessResponse() resumedAggRes := mtest.CreateCommandErrorResponse(mtest.CommandError{ Code: errorHostUnreachable, Name: "foo", Message: "bar", Labels: []string{resumableChangeStreamError}, }) mt.AddMockResponses(aggRes, getMoreRes, killCursorsRes, resumedAggRes) cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) assert.False(mt, cs.Next(context.Background()), "expected Next to return false, got true") }) mt.RunOpts("server selection before resume", mtest.NewOptions().CreateClient(false), func(mt mtest.T) { // ChangeStream will perform server selection before attempting to resume, using initial readPreference mt.Skip("skipping for lack of SDAM monitoring") }) mt.Run("empty batch cursor not closed", func(mt mtest.T) { // Ensure that a cursor returned from an aggregate command with a cursor id and an initial empty batch is not closed cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) assert.True(mt, cs.ID() > 0, "expected non-zero ID, got 0") }) mt.RunOpts("ignore errors from killCursors", mtest.NewOptions().ClientType(mtest.Mock), func(mt mtest.T) { // The killCursors command sent during the "Resume Process" must not be allowed to throw an exception. ns := mt.Coll.Database().Name() + "." + mt.Coll.Name() aggRes := mtest.CreateCursorResponse(1, ns, mtest.FirstBatch) getMoreRes := mtest.CreateCommandErrorResponse(mtest.CommandError{ Code: errorHostUnreachable, Name: "foo", Message: "bar", Labels: []string{"ResumableChangeStreamError"}, }) killCursorsRes := mtest.CreateCommandErrorResponse(mtest.CommandError{ Code: errorInterrupted, Name: "foo", Message: "bar", }) changeDoc := bson.D{{"_id", bson.D{{"x", 1}}}} resumedAggRes := mtest.CreateCursorResponse(1, ns, mtest.FirstBatch, changeDoc) mt.AddMockResponses(aggRes, getMoreRes, killCursorsRes, resumedAggRes) cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) assert.True(mt, cs.Next(context.Background()), "expected Next to return true, got false") assert.Nil(mt, cs.Err(), "change stream error: %v", cs.Err()) }) startAtOpTimeOpts := mtest.NewOptions().MinServerVersion("4.0").MaxServerVersion("4.0.6") mt.RunOpts("include startAtOperationTime", startAtOpTimeOpts, func(mt mtest.T) { // $changeStream stage for ChangeStream against a server >=4.0 and <4.0.7 that has not received any results yet // MUST include a startAtOperationTime option when resuming a changestream. cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) generateEvents(mt, 1) // kill cursor to force resumable error killChangeStreamCursor(mt, cs) mt.ClearEvents() // change stream should resume once and get new change assert.True(mt, cs.Next(context.Background()), "expected Next to return true, got false") // Next should cause getMore, killCursors, and aggregate to run assert.NotNil(mt, mt.GetStartedEvent(), "expected getMore event, got nil") assert.NotNil(mt, mt.GetStartedEvent(), "expected killCursors event, got nil") aggEvent := mt.GetStartedEvent() assert.NotNil(mt, aggEvent, "expected aggregate event, got nil") assert.Equal(mt, "aggregate", aggEvent.CommandName, "expected command name 'aggregate', got '%v'", aggEvent.CommandName) // check for startAtOperationTime in pipeline csStage := aggEvent.Command.Lookup("pipeline").Array().Index(0).Value().Document() // $changeStream stage _, err = csStage.Lookup("$changeStream").Document().LookupErr("startAtOperationTime") assert.Nil(mt, err, "startAtOperationTime not included in aggregate command") }) mt.RunOpts("decode does not panic", noClientOpts, func(mt mtest.T) { testCases := []struct { name string st streamType minServerVersion string }{ {"client", client, "4.0"}, {"database", database, "4.0"}, {"collection", collection, ""}, } for _, tc := range testCases { tcOpts := mtest.NewOptions() if tc.minServerVersion != "" { tcOpts.MinServerVersion(tc.minServerVersion) } mt.RunOpts(tc.name, tcOpts, func(mt mtest.T) { var cs mongo.ChangeStream var err error switch tc.st { case client: cs, err = mt.Client.Watch(context.Background(), mongo.Pipeline{}) case database: cs, err = mt.DB.Watch(context.Background(), mongo.Pipeline{}) case collection: cs, err = mt.Coll.Watch(context.Background(), mongo.Pipeline{}) } assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) generateEvents(mt, 1) assert.True(mt, cs.Next(context.Background()), "expected Next true, got false") var res bson.D err = cs.Decode(&res) assert.Nil(mt, err, "Decode error: %v", err) assert.True(mt, len(res) > 0, "expected non-empty document, got empty") }) } }) mt.Run("maxAwaitTimeMS", func(mt mtest.T) { // maxAwaitTimeMS option should be sent as maxTimeMS on getMore opts := options.ChangeStream().SetMaxAwaitTime(100 time.Millisecond) cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}, opts) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) _, err = mt.Coll.InsertOne(context.Background(), bson.D{{"x", 1}}) assert.Nil(mt, err, "InsertOne error: %v", err) mt.ClearEvents() assert.True(mt, cs.Next(context.Background()), "expected Next true, got false") e := mt.GetStartedEvent() assert.NotNil(mt, e, "expected getMore event, got nil") _, err = e.Command.LookupErr("maxTimeMS") assert.Nil(mt, err, "field maxTimeMS not found in command %v", e.Command) }) mt.RunOpts("resume token", noClientOpts, func(mt mtest.T) { // Prose tests to make assertions on resume tokens for change streams that have not done a getMore yet mt.RunOpts("no getMore", noClientOpts, func(mt mtest.T) { pbrtOpts := mtest.NewOptions().MinServerVersion(minPbrtVersion).CreateClient(false) mt.RunOpts("with PBRT support", pbrtOpts, func(mt mtest.T) { testCases := []struct { name string rt resumeType minServerVersion string }{ {"startAfter", startAfter, minStartAfterVersion}, {"resumeAfter", resumeAfter, minPbrtVersion}, {"neither", operationTime, minPbrtVersion}, } for _, tc := range testCases { tcOpts := mtest.NewOptions().MinServerVersion(tc.minServerVersion) mt.RunOpts(tc.name, tcOpts, func(mt mtest.T) { // create temp stream to get a resume token mt.ClearEvents() cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) // Initial resume token should equal the PBRT in the aggregate command pbrt, opTime := getAggregateResponseInfo(mt) compareResumeTokens(mt, cs, pbrt) numEvents := 5 generateEvents(mt, numEvents) // Iterate over one event to get resume token assert.True(mt, cs.Next(context.Background()), "expected Next to return true, got false") token := cs.ResumeToken() closeStream(cs) var numExpectedEvents int var initialToken bson.Raw var opts options.ChangeStreamOptions switch tc.rt { case startAfter: numExpectedEvents = numEvents - 1 initialToken = token opts = options.ChangeStream().SetStartAfter(token) case resumeAfter: numExpectedEvents = numEvents - 1 initialToken = token opts = options.ChangeStream().SetResumeAfter(token) case operationTime: numExpectedEvents = numEvents opts = options.ChangeStream().SetStartAtOperationTime(&opTime) } // clear slate and create new change stream mt.ClearEvents() cs, err = mt.Coll.Watch(context.Background(), mongo.Pipeline{}, opts) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) aggPbrt, _ := getAggregateResponseInfo(mt) compareResumeTokens(mt, cs, initialToken) for i := 0; i < numExpectedEvents; i++ { assert.True(mt, cs.Next(context.Background()), "expected Next to return true, got false") // while we're not at the last doc in the batch, the resume token should be the _id of the // document if i != numExpectedEvents-1 { compareResumeTokens(mt, cs, cs.Current.Lookup("_id").Document()) } } // at end of batch, the resume token should equal the PBRT of the aggregate compareResumeTokens(mt, cs, aggPbrt) }) } }) noPbrtOpts := mtest.NewOptions().MaxServerVersion("4.0.6") mt.RunOpts("without PBRT support", noPbrtOpts, func(mt mtest.T) { collName := mt.Coll.Name() dbName := mt.Coll.Database().Name() cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) compareResumeTokens(mt, cs, nil) // should be no resume token because no PBRT numEvents := 5 generateEvents(mt, numEvents) // iterate once to get a resume token assert.True(mt, cs.Next(context.Background()), "expected Next to return true, got false") token := cs.ResumeToken() assert.NotNil(mt, token, "expected resume token, got nil") testCases := []struct { name string opts options.ChangeStreamOptions iterateStream bool // whether or not resulting change stream should be iterated initialToken bson.Raw numDocsExpected int }{ {"resumeAfter", options.ChangeStream().SetResumeAfter(token), true, token, numEvents - 1}, {"no options", nil, false, nil, 0}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { coll := mt.Client.Database(dbName).Collection(collName) cs, err := coll.Watch(context.Background(), mongo.Pipeline{}, tc.opts) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) compareResumeTokens(mt, cs, tc.initialToken) if !tc.iterateStream { return } for i := 0; i < tc.numDocsExpected; i++ { assert.True(mt, cs.Next(context.Background()), "expected Next to return true, got false") // current resume token should always equal _id of current document compareResumeTokens(mt, cs, cs.Current.Lookup("_id").Document()) } }) } }) }) }) mt.RunOpts("try next", noClientOpts, func(mt mtest.T) { mt.Run("existing non-empty batch", func(mt mtest.T) { // If there's already documents in the current batch, TryNext should return true without doing a getMore cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) generateEvents(mt, 5) // call Next to make sure a batch is retrieved assert.True(mt, cs.Next(context.Background()), "expected Next to return true, got false") tryNextExistingBatchTest(mt, cs) }) mt.Run("one getMore sent", func(mt mtest.T) { // If the current batch is empty, TryNext should send one getMore and return. cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) mt.ClearEvents() // first call to TryNext should return false because first batch was empty so batch cursor returns false // without doing a getMore // next call to TryNext should attempt a getMore for i := 0; i < 2; i++ { assert.False(mt, cs.TryNext(context.Background()), "TryNext returned true on iteration %v", i) } verifyOneGetmoreSent(mt) }) mt.RunOpts("getMore error", mtest.NewOptions().ClientType(mtest.Mock), func(mt mtest.T) { // If the getMore attempt errors with a non-resumable error, TryNext returns false aggRes := mtest.CreateCursorResponse(50, "foo.bar", mtest.FirstBatch) mt.AddMockResponses(aggRes) cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) tryNextGetmoreError(mt, cs) }) }) customDeploymentOpts := mtest.NewOptions(). Topologies(mtest.ReplicaSet). // Avoid complexity of sharded fail points. MinServerVersion("4.0"). // 4.0 is needed to use replica set fail points. CreateClient(false) mt.RunOpts("custom deployment", customDeploymentOpts, func(mt mtest.T) { // Tests for the changeStreamDeployment type. These are written as integration tests for ChangeStream rather // than unit/integration tests for changeStreamDeployment to ensure that the deployment is correctly wired // by ChangeStream when executing an aggregate. mt.Run("errors are processed for SDAM on initial aggregate", func(mt mtest.T) { tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(options.Client(). SetPoolMonitor(tpm.PoolMonitor). SetWriteConcern(mtest.MajorityWc). SetReadConcern(mtest.MajorityRc). SetRetryReads(false)) mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"aggregate"}, CloseConnection: true, }, }) _, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.NotNil(mt, err, "expected Watch error, got nil") assert.True(mt, tpm.IsPoolCleared(), "expected pool to be cleared after non-timeout network error but was not") }) mt.Run("errors are processed for SDAM on getMore", func(mt mtest.T) { tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(options.Client(). SetPoolMonitor(tpm.PoolMonitor). SetWriteConcern(mtest.MajorityWc). SetReadConcern(mtest.MajorityRc). SetRetryReads(false)) mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"getMore"}, CloseConnection: true, }, }) cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) _, err = mt.Coll.InsertOne(context.Background(), bson.D{{"x", 1}}) assert.Nil(mt, err, "InsertOne error: %v", err) assert.True(mt, cs.Next(context.Background()), "expected Next to return true, got false (iteration error %v)", cs.Err()) assert.True(mt, tpm.IsPoolCleared(), "expected pool to be cleared after non-timeout network error but was not") }) mt.Run("errors are processed for SDAM on retried aggregate", func(mt mtest.T) { tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(options.Client(). SetPoolMonitor(tpm.PoolMonitor). SetRetryReads(true)) mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 2, }, Data: mtest.FailPointData{ FailCommands: []string{"aggregate"}, CloseConnection: true, }, }) _, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.NotNil(mt, err, "expected Watch error, got nil") clearedEvents := tpm.Events(func(evt event.PoolEvent) bool { return evt.Type == event.PoolCleared }) assert.Equal(mt, 2, len(clearedEvents), "expected two PoolCleared events, got %d", len(clearedEvents)) }) }) // Setting min server version as 4.0 since v3.6 does not send a "dropEvent" mt.RunOpts("call to cursor.Next after cursor closed", mtest.NewOptions().MinServerVersion("4.0"), func(mt mtest.T) { cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) // Generate insert events generateEvents(mt, 5) // Call Coll.Drop to generate drop and invalidate event err = mt.Coll.Drop(context.Background()) assert.Nil(mt, err, "Drop error: %v", err) // Test that all events were successful for i := 0; i < 7; i++ { assert.True(mt, cs.Next(context.Background()), "Next returned false at index %d; iteration error: %v", i, cs.Err()) } operationType := cs.Current.Lookup("operationType").StringValue() assert.Equal(mt, operationType, "invalidate", "expected invalidate event but returned %q event", operationType) // next call to cs.Next should return False since cursor is closed assert.False(mt, cs.Next(context.Background()), "expected to return false, but returned true") }) mt.Run("getMore commands are monitored", func(mt mtest.T) { cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) _, err = mt.Coll.InsertOne(context.Background(), bson.M{"x": 1}) assert.Nil(mt, err, "InsertOne error: %v", err) mt.ClearEvents() assert.True(mt, cs.Next(context.Background()), "Next returned false with error %v", cs.Err()) evt := mt.GetStartedEvent() assert.Equal(mt, "getMore", evt.CommandName, "expected command 'getMore', got %q", evt.CommandName) }) mt.Run("killCursors commands are monitored", func(mt mtest.T) { cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) mt.ClearEvents() err = cs.Close(context.Background()) assert.Nil(mt, err, "Close error: %v", err) evt := mt.GetStartedEvent() assert.Equal(mt, "killCursors", evt.CommandName, "expected command 'killCursors', got %q", evt.CommandName) }) mt.Run("Custom", func(mt mtest.T) { // Custom options should be a BSON map of option names to Marshalable option values. // We use "allowDiskUse" as an example. customOpts := bson.M{"allowDiskUse": true} opts := options.ChangeStream().SetCustom(customOpts) // Create change stream with custom options set. mt.ClearEvents() cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}, opts) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) // Assert that custom option is passed to the initial aggregate. evt := mt.GetStartedEvent() assert.Equal(mt, "aggregate", evt.CommandName, "expected command 'aggregate' got, %q", evt.CommandName) aduVal, err := evt.Command.LookupErr("allowDiskUse") assert.Nil(mt, err, "expected field 'allowDiskUse' in started command not found") adu, ok := aduVal.BooleanOK() assert.True(mt, ok, "expected field 'allowDiskUse' to be boolean, got %v", aduVal.Type.String()) assert.True(mt, adu, "expected field 'allowDiskUse' to be true, got false") }) mt.RunOpts("CustomPipeline", mtest.NewOptions().MinServerVersion("4.0"), func(mt mtest.T) { // Custom pipeline options should be a BSON map of option names to Marshalable option values. // We use "allChangesForCluster" as an example. customPipelineOpts := bson.M{"allChangesForCluster": false} opts := options.ChangeStream().SetCustomPipeline(customPipelineOpts) // Create change stream with custom pipeline options set. mt.ClearEvents() cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}, opts) assert.Nil(mt, err, "Watch error: %v", err) defer closeStream(cs) // Assert that custom pipeline option is included in the $changeStream stage. evt := mt.GetStartedEvent() assert.Equal(mt, "aggregate", evt.CommandName, "expected command 'aggregate' got, %q", evt.CommandName) acfcVal, err := evt.Command.LookupErr("pipeline", "0", "$changeStream", "allChangesForCluster") assert.Nil(mt, err, "expected field 'allChangesForCluster' in $changeStream stage not found") acfc, ok := acfcVal.BooleanOK() assert.True(mt, ok, "expected field 'allChangesForCluster' to be boolean, got %v", acfcVal.Type.String()) assert.False(mt, acfc, "expected field 'allChangesForCluster' to be false, got %v", acfc) }) withBSONOpts := mtest.NewOptions().ClientOptions( options.Client().SetBSONOptions(&options.BSONOptions{ UseJSONStructTags: true, })) mt.RunOpts("with BSONOptions", withBSONOpts, func(mt mtest.T) { cs, err := mt.Coll.Watch(context.Background(), mongo.Pipeline{}) require.NoError(mt, err, "Watch error") defer closeStream(cs) type myDocument struct { A string `json:"x"` } var wg sync.WaitGroup wg.Add(1) go func() { defer wg.Done() _, err := mt.Coll.InsertOne(context.Background(), myDocument{A: "foo"}) require.NoError(mt, err, "InsertOne error") }() cs.Next(context.Background()) var got struct { FullDocument myDocument `bson:"fullDocument"` } err = cs.Decode(&got) require.NoError(mt, err, "Decode error") want := myDocument{ A: "foo", } assert.Equal(mt, want, got.FullDocument, "expected and actual Decode results are different") wg.Wait() }) splitLargeChangesCollOpts := options. CreateCollection(). SetChangeStreamPreAndPostImages(bson.M{"enabled": true}) splitLargeChangesOpts := mtOpts. MinServerVersion("6.0.9"). CreateClient(true). CollectionCreateOptions(splitLargeChangesCollOpts) mt.RunOpts("split large changes", splitLargeChangesOpts, func(mt mtest.T) { type idValue struct { ID int32 `bson:"_id"` Value string `bson:"value"` } doc := idValue{ ID: 1, Value: "q" + strings.Repeat("q", 1010241024), } // Insert the document _, err := mt.Coll.InsertOne(context.Background(), doc) require.NoError(t, err, "failed to insert idValue") // Watch for change events pipeline := mongo.Pipeline{ {{"$changeStreamSplitLargeEvent", bson.D{}}}, } opts := options.ChangeStream().SetFullDocument(options.Required) cs, err := mt.Coll.Watch(context.Background(), pipeline, opts) require.NoError(t, err, "failed to watch collection") defer closeStream(cs) var wg sync.WaitGroup wg.Add(1) go func() { defer wg.Done() filter := bson.D{{"_id", int32(1)}} update := bson.D{{"$set", bson.D{{"value", "z" + strings.Repeat("q", 1010241024)}}}} _, err := mt.Coll.UpdateOne(context.Background(), filter, update) require.NoError(mt, err, "failed to update idValue") }() nextCtx, cancel := context.WithTimeout(context.Background(), 10time.Second) t.Cleanup(cancel) type splitEvent struct { Fragment int32 `bson:"fragment"` Of int32 `bson:"of"` } got := struct { SplitEvent splitEvent `bson:"splitEvent"` }{} cs.Next(nextCtx) err = cs.Decode(&got) require.NoError(mt, err, "failed to decode first iteration") want := splitEvent{ Fragment: 1, Of: 2, } assert.Equal(mt, want, got.SplitEvent, "expected and actual Decode results are different") cs.Next(nextCtx) err = cs.Decode(&got) require.NoError(mt, err, "failed to decoded second iteration") want = splitEvent{ Fragment: 2, Of: 2, } assert.Equal(mt, want, got.SplitEvent, "expected and actual decode results are different") wg.Wait() }) } func closeStream(cs mongo.ChangeStream) { _ = cs.Close(context.Background()) } func generateEvents(mt mtest.T, numEvents int) { mt.Helper() for i := 0; i < numEvents; i++ { doc := bson.D{{"x", i}} _, err := mt.Coll.InsertOne(context.Background(), doc) assert.Nil(mt, err, "InsertOne error on document %v: %v", doc, err) } } func killChangeStreamCursor(mt mtest.T, cs mongo.ChangeStream) { mt.Helper() db := mt.Coll.Database().Client().Database("admin") err := db.RunCommand(context.Background(), bson.D{ {"killCursors", mt.Coll.Name()}, {"cursors", bson.A{cs.ID()}}, }).Err() assert.Nil(mt, err, "killCursors error: %v", err) } // returns pbrt, operationTime from aggregate command response func getAggregateResponseInfo(mt mtest.T) (bson.Raw, primitive.Timestamp) { mt.Helper() succeeded := mt.GetSucceededEvent() assert.NotNil(mt, succeeded, "expected success event for aggregate, got nil") assert.Equal(mt, "aggregate", succeeded.CommandName, "expected command name 'aggregate', got '%v'", succeeded.CommandName) pbrt := succeeded.Reply.Lookup("cursor", "postBatchResumeToken").Document() optimeT, optimeI := succeeded.Reply.Lookup("operationTime").Timestamp() return pbrt, primitive.Timestamp{T: optimeT, I: optimeI} } func compareResumeTokens(mt mtest.T, cs mongo.ChangeStream, expected bson.Raw) { mt.Helper() assert.Equal(mt, expected, cs.ResumeToken(), "expected resume token %v, got %v", expected, cs.ResumeToken()) }	32.18 KB	2025-05-25 12:27
📄 clam_prose_test.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "fmt" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/integtest" "go.mongodb.org/mongo-driver/internal/logger" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" ) var ErrInvalidTruncation = fmt.Errorf("invalid truncation") func clamTruncErr(mt mtest.T, op string, want, got int) error { mt.Helper() return fmt.Errorf("%w: expected length %s %d, got %d", ErrInvalidTruncation, op, want, got) } func clamDefaultTruncLimitOp(ctx context.Context, mt mtest.T, coll mongo.Collection) { mt.Helper() const documentsSize = 100 // Construct an array of docs containing the document {"x" : "y"} // repeated "documentSize" times. docs := []interface{}{} for i := 0; i < documentsSize; i++ { docs = append(docs, bson.D{{"x", "y"}}) } // Insert docs to a the collection. _, err := coll.InsertMany(ctx, docs) assert.Nil(mt, err, "InsertMany error: %v", err) // Run find() on the collection. _, err = coll.Find(ctx, bson.D{}) assert.Nil(mt, err, "Find error: %v", err) } func clamDefaultTruncLimitLogs(mt mtest.T) []truncValidator { mt.Helper() const cmd = "command" const rpl = "reply" expTruncLen := len(logger.TruncationSuffix) + logger.DefaultMaxDocumentLength validators := make([]truncValidator, 4) // Insert started. validators[0] = newTruncValidator(mt, cmd, func(cmd string) error { if len(cmd) != expTruncLen { return clamTruncErr(mt, "=", expTruncLen, len(cmd)) } return nil }) // Insert succeeded. validators[1] = newTruncValidator(mt, rpl, func(cmd string) error { if len(cmd) > expTruncLen { return clamTruncErr(mt, "<=", expTruncLen, len(cmd)) } return nil }) // Find started, nothing to validate. validators[2] = nil // Find succeeded. validators[3] = newTruncValidator(mt, rpl, func(cmd string) error { if len(cmd) != expTruncLen { return clamTruncErr(mt, "=", expTruncLen, len(cmd)) } return nil }) return validators } func clamExplicitTruncLimitOp(ctx context.Context, mt mtest.T, coll mongo.Collection) { mt.Helper() result := coll.Database().RunCommand(ctx, bson.D{{"hello", true}}) assert.Nil(mt, result.Err(), "RunCommand error: %v", result.Err()) } func clamExplicitTruncLimitLogs(mt mtest.T) []truncValidator { mt.Helper() const cmd = "command" const rpl = "reply" expTruncLen := len(logger.TruncationSuffix) + 5 validators := make([]truncValidator, 2) // Hello started. validators[0] = newTruncValidator(mt, cmd, func(cmd string) error { if len(cmd) != expTruncLen { return clamTruncErr(mt, "=", expTruncLen, len(cmd)) } return nil }) // Hello succeeded. validators[1] = newTruncValidator(mt, rpl, func(cmd string) error { if len(cmd) != expTruncLen { return clamTruncErr(mt, "=", expTruncLen, len(cmd)) } return nil }) return validators } func clamExplicitTruncLimitFailOp(ctx context.Context, mt mtest.T, coll mongo.Collection) { mt.Helper() result := coll.Database().RunCommand(ctx, bson.D{{"notARealCommand", true}}) assert.NotNil(mt, result.Err(), "expected RunCommand error, got: %v", result.Err()) } func clamExplicitTruncLimitFailLogs(mt mtest.T) []truncValidator { mt.Helper() const fail = "failure" expTruncLen := len(logger.TruncationSuffix) + 5 validators := make([]truncValidator, 2) // Hello started, nothing to validate. validators[0] = nil // Hello failed. validators[1] = newTruncValidator(mt, fail, func(cmd string) error { if len(cmd) != expTruncLen { return clamTruncErr(mt, "=", expTruncLen, len(cmd)) } return nil }) return validators } // clamMultiByteTrunc runs an operation to insert a very large document with the // multi-byte character "界" repeated a large number of times. This repetition // is done to categorically ensure that the truncation point is made somewhere // within the multi-byte character. For example a typical insertion reply may // look something like this: // // {"insert": "setuptest","ordered": true,"lsid": {"id": ... // // We have no control over how the "header" portion of this reply is formatted. // Over time the server might support newer fields or change the formatting of // existing fields. This means that the truncation point could be anywhere in // the "header" portion of the reply. A large document lowers the likelihood of // the truncation point being in the "header" portion of the reply. func clamMultiByteTrunc(ctx context.Context, mt mtest.T, coll mongo.Collection) { mt.Helper() const multiByteCharStrLen = 50_000 const strToRepeat = "界" // Repeat the string "strToRepeat" "multiByteCharStrLen" times. multiByteCharStr := "" for i := 0; i < multiByteCharStrLen; i++ { multiByteCharStr += strToRepeat } _, err := coll.InsertOne(ctx, bson.D{{"x", multiByteCharStr}}) assert.Nil(mt, err, "InsertOne error: %v", err) } func clamMultiByteTruncLogs(mt mtest.T) []truncValidator { mt.Helper() const cmd = "command" const strToRepeat = "界" validators := make([]truncValidator, 2) // Insert started. validators[0] = newTruncValidator(mt, cmd, func(cmd string) error { // Remove the suffix from the command string. cmd = cmd[:len(cmd)-len(logger.TruncationSuffix)] // Get the last 3 bytes of the command string. last3Bytes := cmd[len(cmd)-3:] // Make sure the last 3 bytes are the multi-byte character. if last3Bytes != strToRepeat { return fmt.Errorf("expected last 3 bytes to be %q, got %q", strToRepeat, last3Bytes) } return nil }) return validators } func TestCommandLoggingAndMonitoringProse(t testing.T) { t.Parallel() mt := mtest.New(t, mtest.NewOptions().CreateClient(false)) for _, tcase := range []struct { // name is the name of the test case name string // collectionName is the name to assign the collection for // processing the operations. This should be unique across test // cases. collectionName string // maxDocumentLength is the maximum document length for a // command message. maxDocumentLength uint // orderedLogValidators is a slice of log validators that should // be 1-1 with the actual logs that are propagated by the // LogSink. The order here matters, the first log will be // validated by the 0th validator, the second log will be // validated by the 1st validator, etc. orderedLogValidators []truncValidator // operation is the operation to perform on the collection that // will result in log propagation. The logs created by // "operation" will be validated against the // "orderedLogValidators." operation func(context.Context, mtest.T, mongo.Collection) // Setup is a function that will be run before the test case. // Operations performed in this function will not be logged. setup func(context.Context, mtest.T, mongo.Collection) }{ { name: "1 Default truncation limit", collectionName: "46a624c57c72463d90f88a733e7b28b4", operation: clamDefaultTruncLimitOp, orderedLogValidators: clamDefaultTruncLimitLogs(mt), }, { name: "2 Explicitly configured truncation limit", collectionName: "540baa64dc854ca2a639627e2f0918df", maxDocumentLength: 5, operation: clamExplicitTruncLimitOp, orderedLogValidators: clamExplicitTruncLimitLogs(mt), }, { name: "2 Explicitly configured truncation limit for failures", collectionName: "aff43dfcaa1a4014b58aaa9606f5bd44", maxDocumentLength: 5, operation: clamExplicitTruncLimitFailOp, orderedLogValidators: clamExplicitTruncLimitFailLogs(mt), }, // The third test case is to ensure that a truncation point made // within a multi-byte character is handled correctly. The // chosen multi-byte character for this test is "界" (U+754C). // This character is repeated a large number of times (50,000). // We need to run this test 3 times to ensure that the // truncation occurs at a middle point within the multi-byte // character at least once (at most twice). { name: "3.1 Truncation with multi-byte codepoints", collectionName: "5ed6d1b7-e358-438a-b067-e1d1dd10fee1", maxDocumentLength: 20_000, operation: clamMultiByteTrunc, orderedLogValidators: clamMultiByteTruncLogs(mt), }, { name: "3.2 Truncation with multi-byte codepoints", collectionName: "5ed6d1b7-e358-438a-b067-e1d1dd10fee1", maxDocumentLength: 20_001, operation: clamMultiByteTrunc, orderedLogValidators: clamMultiByteTruncLogs(mt), }, { name: "3.3 Truncation with multi-byte codepoints", collectionName: "5ed6d1b7-e358-438a-b067-e1d1dd10fee1", maxDocumentLength: 20_002, operation: clamMultiByteTrunc, orderedLogValidators: clamMultiByteTruncLogs(mt), }, } { tcase := tcase mt.Run(tcase.name, func(mt mtest.T) { mt.Parallel() const deadline = 10 time.Second ctx := context.Background() // Before the test case, we need to see if there is a // setup function to run. if tcase.setup != nil { clientOpts := options.Client().ApplyURI(mtest.ClusterURI()) // Create a context with a deadline so that the // test setup doesn't hang forever. ctx, cancel := context.WithTimeout(ctx, deadline) defer cancel() integtest.AddTestServerAPIVersion(clientOpts) client, err := mongo.Connect(ctx, clientOpts) assert.Nil(mt, err, "Connect error in setup: %v", err) coll := mt.CreateCollection(mtest.Collection{ Name: tcase.collectionName, Client: client, }, false) tcase.setup(ctx, mt, coll) } // If there is no operation, then we don't need to run // the test case. if tcase.operation == nil { return } // If there are no log validators, then we should error. if len(tcase.orderedLogValidators) == 0 { mt.Fatalf("no log validators provided") } sinkCtx, sinkCancel := context.WithDeadline(ctx, time.Now().Add(deadline)) defer sinkCancel() validator := func(order int, level int, msg string, keysAndValues ...interface{}) error { // If the order exceeds the length of the // "orderedCaseValidators," then throw an error. if order >= len(tcase.orderedLogValidators) { return fmt.Errorf("not enough expected cases to validate") } caseValidator := tcase.orderedLogValidators[order] if caseValidator == nil { return nil } return tcase.orderedLogValidators[order](keysAndValues...) } sink := newTestLogSink(sinkCtx, mt, len(tcase.orderedLogValidators), validator) // Configure logging with a minimum severity level of // "debug" for the "command" component without // explicitly configuring the max document length. loggerOpts := options.Logger().SetSink(sink). SetComponentLevel(options.LogComponentCommand, options.LogLevelDebug) // If the test case requires a maximum document length, // then configure it. if mdl := tcase.maxDocumentLength; mdl != 0 { loggerOpts.SetMaxDocumentLength(mdl) } clientOpts := options.Client().SetLoggerOptions(loggerOpts).ApplyURI(mtest.ClusterURI()) integtest.AddTestServerAPIVersion(clientOpts) client, err := mongo.Connect(context.Background(), clientOpts) assert.Nil(mt, err, "Connect error: %v", err) coll := mt.CreateCollection(mtest.Collection{ Name: tcase.collectionName, Client: client, }, false) tcase.operation(ctx, mt, coll) // Verify the logs. if err := <-sink.errs(); err != nil { mt.Fatalf("unexpected error: %v", err) } }) } }	11.76 KB	2025-05-25 12:27
📄 client_options_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "net" "sync/atomic" "testing" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/integtest" "go.mongodb.org/mongo-driver/internal/require" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/options" ) func TestClientOptions_CustomDialer(t testing.T) { td := &testDialer{d: &net.Dialer{}} cs := integtest.ConnString(t) opts := options.Client().ApplyURI(cs.String()).SetDialer(td) integtest.AddTestServerAPIVersion(opts) client, err := mongo.NewClient(opts) require.NoError(t, err) err = client.Connect(context.Background()) require.NoError(t, err) _, err = client.ListDatabases(context.Background(), bson.D{}) require.NoError(t, err) got := atomic.LoadInt32(&td.called) if got < 1 { t.Errorf("Custom dialer was not used when dialing new connections") } } type testDialer struct { called int32 d mongo.Dialer } func (td testDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) { atomic.AddInt32(&td.called, 1) return td.d.DialContext(ctx, network, address) }	1.35 KB	2025-05-25 12:27
📄 client_side_encryption_prose_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 //go:build cse // +build cse package integration import ( "context" "crypto/tls" "encoding/base64" "fmt" "io/ioutil" "net" "net/http" "os" "path/filepath" "strings" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/handshake" "go.mongodb.org/mongo-driver/internal/integtest" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/mongo/writeconcern" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" "go.mongodb.org/mongo-driver/x/mongo/driver/mongocrypt" mongocryptopts "go.mongodb.org/mongo-driver/x/mongo/driver/mongocrypt/options" ) var ( localMasterKey = []byte("2x44+xduTaBBkY16Er5DuADaghvS4vwdkg8tpPp3tz6gV01A1CwbD9itQ2HFDgPWOp8eMaC1Oi766JzXZBdBdbdMurdonJ1d") ) const ( clientEncryptionProseDir = "../../testdata/client-side-encryption-prose" deterministicAlgorithm = "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic" randomAlgorithm = "AEAD_AES_256_CBC_HMAC_SHA_512-Random" kvNamespace = "keyvault.datakeys" // default namespace for the key vault collection keySubtype byte = 4 // expected subtype for data keys encryptedValueSubtype byte = 6 // expected subtypes for encrypted values cryptMaxBatchSizeBytes = 2097152 // max bytes in write batch when auto encryption is enabled maxBsonObjSize = 16777216 // max bytes in BSON object ) func containsSubstring(possibleSubstrings []string, str string) bool { for _, possibleSubstring := range possibleSubstrings { if strings.Contains(str, possibleSubstring) { return true } } return false } func TestClientSideEncryptionProse(t testing.T) { t.Parallel() verifyClientSideEncryptionVarsSet(t) mt := mtest.New(t, mtest.NewOptions().MinServerVersion("4.2").Enterprise(true).CreateClient(false)) defaultKvClientOptions := options.Client().ApplyURI(mtest.ClusterURI()) integtest.AddTestServerAPIVersion(defaultKvClientOptions) fullKmsProvidersMap := map[string]map[string]interface{}{ "aws": { "accessKeyId": awsAccessKeyID, "secretAccessKey": awsSecretAccessKey, }, "azure": { "tenantId": azureTenantID, "clientId": azureClientID, "clientSecret": azureClientSecret, }, "gcp": { "email": gcpEmail, "privateKey": gcpPrivateKey, }, "local": {"key": localMasterKey}, "kmip": { "endpoint": "localhost:5698", }, } mt.Run("1. custom key material test", func(mt mtest.T) { const ( dkCollection = "datakeys" idKey = "_id" kvDatabase = "keyvault" ) // Create a ClientEncryption object (referred to as client_encryption) with client set as the keyVaultClient. // Using client, drop the collection keyvault.datakeys. cse := setup(mt, nil, defaultKvClientOptions, options.ClientEncryption(). SetKmsProviders(fullKmsProvidersMap). SetKeyVaultNamespace(kvNamespace)) err := cse.kvClient.Database(kvDatabase).Collection(dkCollection).Drop(context.Background()) assert.Nil(mt, err, "error dropping %q namespace: %v", kvNamespace, err) // Using client_encryption, create a data key with a local KMS provider and the declared b64 custom key material // (given as base64). const b641 = `xPTAjBRG5JiPm+d3fj6XLi2q5DMXUS/f1f+SMAlhhwkhDRL0kr8r9GDLIGTAGlvC+HVjSIgdL+RKwZCvpXSyxTICWSXT` + `UYsWYPyu3IoHbuBZdmw2faM3WhcRIgbMReU5` // Decode the base64-encoded keyMaterial string. km, err := base64.StdEncoding.DecodeString(b641) assert.Nil(mt, err, "error decoding b64: %v", err) _, err = cse.clientEnc.CreateDataKey(context.Background(), "local", options.DataKey().SetKeyMaterial(km)) assert.Nil(mt, err, "error creating data key: %v", err) // Find the resulting key document in keyvault.datakeys, save a copy of the key document, then remove the key // document from the collection. coll := cse.kvClient.Database(kvDatabase).Collection(dkCollection) keydoc, err := coll.FindOne(context.Background(), bson.D{}).Raw() assert.Nil(mt, err, "error in decoding bytes: %v", err) // Remove the key document from the collection. id, err := keydoc.LookupErr(idKey) assert.Nil(mt, err, "error looking up %s: %v", idKey, err) _, err = coll.DeleteOne(context.Background(), bson.D{{idKey, id}}) assert.Nil(mt, err, "error deleting key document: %v", err) // Replace the _id field in the copied key document with a UUID with base64 value AAAAAAAAAAAAAAAAAAAAAA== (16 // bytes all equal to 0x00) and insert the modified key document into keyvault.datakeys with majority write // concern. cidx, alteredKeydoc := bsoncore.AppendDocumentStart(nil) docElems, _ := keydoc.Elements() for _, element := range docElems { if key := element.Key(); key != idKey { alteredKeydoc = bsoncore.AppendValueElement(alteredKeydoc, key, rawValueToCoreValue(element.Value())) } } empty := [16]byte{} uuidSubtype, _ := keydoc.Lookup(idKey).Binary() alteredKeydoc = bsoncore.AppendBinaryElement(alteredKeydoc, idKey, uuidSubtype, empty[:]) alteredKeydoc, _ = bsoncore.AppendDocumentEnd(alteredKeydoc, cidx) // Insert the copied key document into keyvault.datakeys with majority write concern. wcMajority := writeconcern.New(writeconcern.WMajority(), writeconcern.WTimeout(1time.Second)) wcMajorityCollectionOpts := options.Collection().SetWriteConcern(wcMajority) wcmColl := cse.kvClient.Database(kvDatabase).Collection(dkCollection, wcMajorityCollectionOpts) _, err = wcmColl.InsertOne(context.Background(), alteredKeydoc) assert.Nil(mt, err, "error inserting altered key document: %v", err) // Using client_encryption, encrypt the string "test" with the modified data key using the // AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic algorithm and assert the resulting value is equal to the // declared b64 constant. const b642 = `AQAAAAAAAAAAAAAAAAAAAAACz0ZOLuuhEYi807ZXTdhbqhLaS2/t9wLifJnnNYwiw79d75QYIZ6M/aYC1h9nCzCjZ7pG` + `UpAuNnkUhnIXM3PjrA==` empty = [16]byte{} keyid := primitive.Binary{Subtype: 0x04, Data: empty[:]} encOpts := options.Encrypt().SetAlgorithm(deterministicAlgorithm).SetKeyID(keyid) testVal := bson.RawValue{ Type: bson.TypeString, Value: bsoncore.AppendString(nil, "test"), } actual, err := cse.clientEnc.Encrypt(context.Background(), testVal, encOpts) assert.Nil(mt, err, "error encrypting data: %v", err) expected := primitive.Binary{Subtype: 0x06} expected.Data, _ = base64.StdEncoding.DecodeString(b642) assert.Equal(t, actual, expected, "expected: %v, got: %v", actual, expected) }) mt.RunOpts("2. data key and double encryption", noClientOpts, func(mt mtest.T) { // set up options structs schema := bson.D{ {"bsonType", "object"}, {"properties", bson.D{ {"encrypted_placeholder", bson.D{ {"encrypt", bson.D{ {"keyId", "/placeholder"}, {"bsonType", "string"}, {"algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Random"}, }}, }}, }}, } schemaMap := map[string]interface{}{"db.coll": schema} tlsConfig := make(map[string]tls.Config) if tlsCAFileKMIP != "" && tlsClientCertificateKeyFileKMIP != "" { tlsOpts := map[string]interface{}{ "tlsCertificateKeyFile": tlsClientCertificateKeyFileKMIP, "tlsCAFile": tlsCAFileKMIP, } kmipConfig, err := options.BuildTLSConfig(tlsOpts) assert.Nil(mt, err, "BuildTLSConfig error: %v", err) tlsConfig["kmip"] = kmipConfig } aeo := options.AutoEncryption(). SetKmsProviders(fullKmsProvidersMap). SetKeyVaultNamespace(kvNamespace). SetSchemaMap(schemaMap). SetTLSConfig(tlsConfig). SetExtraOptions(getCryptSharedLibExtraOptions()) ceo := options.ClientEncryption(). SetKmsProviders(fullKmsProvidersMap). SetKeyVaultNamespace(kvNamespace). SetTLSConfig(tlsConfig) awsMasterKey := bson.D{ {"region", "us-east-1"}, {"key", "arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0"}, } azureMasterKey := bson.D{ {"keyVaultEndpoint", "key-vault-csfle.vault.azure.net"}, {"keyName", "key-name-csfle"}, } gcpMasterKey := bson.D{ {"projectId", "devprod-drivers"}, {"location", "global"}, {"keyRing", "key-ring-csfle"}, {"keyName", "key-name-csfle"}, } kmipMasterKey := bson.D{} testCases := []struct { provider string masterKey interface{} }{ {"local", nil}, {"aws", awsMasterKey}, {"azure", azureMasterKey}, {"gcp", gcpMasterKey}, {"kmip", kmipMasterKey}, } for _, tc := range testCases { mt.Run(tc.provider, func(mt mtest.T) { if tc.provider == "kmip" && "" == os.Getenv("KMS_MOCK_SERVERS_RUNNING") { mt.Skipf("Skipping test as KMS_MOCK_SERVERS_RUNNING is not set") } var startedEvents []event.CommandStartedEvent monitor := &event.CommandMonitor{ Started: func(_ context.Context, evt event.CommandStartedEvent) { startedEvents = append(startedEvents, evt) }, } kvClientOpts := options.Client().ApplyURI(mtest.ClusterURI()).SetMonitor(monitor) integtest.AddTestServerAPIVersion(kvClientOpts) cpt := setup(mt, aeo, kvClientOpts, ceo) defer cpt.teardown(mt) // create data key keyAltName := fmt.Sprintf("%s_altname", tc.provider) dataKeyOpts := options.DataKey().SetKeyAltNames([]string{keyAltName}) if tc.masterKey != nil { dataKeyOpts.SetMasterKey(tc.masterKey) } dataKeyID, err := cpt.clientEnc.CreateDataKey(context.Background(), tc.provider, dataKeyOpts) assert.Nil(mt, err, "CreateDataKey error: %v", err) assert.Equal(mt, keySubtype, dataKeyID.Subtype, "expected data key subtype %v, got %v", keySubtype, dataKeyID.Subtype) // assert that the key exists in the key vault cursor, err := cpt.keyVaultColl.Find(context.Background(), bson.D{{"_id", dataKeyID}}) assert.Nil(mt, err, "key vault Find error: %v", err) assert.True(mt, cursor.Next(context.Background()), "no keys found in key vault") provider := cursor.Current.Lookup("masterKey", "provider").StringValue() assert.Equal(mt, tc.provider, provider, "expected provider %v, got %v", tc.provider, provider) assert.False(mt, cursor.Next(context.Background()), "unexpected document in key vault: %v", cursor.Current) // verify that the key was inserted using write concern majority assert.Equal(mt, 1, len(startedEvents), "expected 1 CommandStartedEvent, got %v", len(startedEvents)) evt := startedEvents[0] assert.Equal(mt, "insert", evt.CommandName, "expected command 'insert', got '%v'", evt.CommandName) writeConcernVal, err := evt.Command.LookupErr("writeConcern") assert.Nil(mt, err, "expected writeConcern in command %s", evt.Command) wString := writeConcernVal.Document().Lookup("w").StringValue() assert.Equal(mt, "majority", wString, "expected write concern 'majority', got %v", wString) // encrypt a value with the new key by ID valueToEncrypt := fmt.Sprintf("hello %s", tc.provider) rawVal := bson.RawValue{Type: bson.TypeString, Value: bsoncore.AppendString(nil, valueToEncrypt)} encrypted, err := cpt.clientEnc.Encrypt(context.Background(), rawVal, options.Encrypt().SetAlgorithm(deterministicAlgorithm).SetKeyID(dataKeyID)) assert.Nil(mt, err, "Encrypt error while encrypting value by ID: %v", err) assert.Equal(mt, encryptedValueSubtype, encrypted.Subtype, "expected encrypted value subtype %v, got %v", encryptedValueSubtype, encrypted.Subtype) // insert an encrypted value. the value shouldn't be encrypted again because it's not in the schema. _, err = cpt.cseColl.InsertOne(context.Background(), bson.D{{"_id", tc.provider}, {"value", encrypted}}) assert.Nil(mt, err, "InsertOne error: %v", err) // find the inserted document. the value should be decrypted automatically resBytes, err := cpt.cseColl.FindOne(context.Background(), bson.D{{"_id", tc.provider}}).Raw() assert.Nil(mt, err, "Find error: %v", err) foundVal := resBytes.Lookup("value").StringValue() assert.Equal(mt, valueToEncrypt, foundVal, "expected value %v, got %v", valueToEncrypt, foundVal) // encrypt a value with an alternate name for the new key altEncrypted, err := cpt.clientEnc.Encrypt(context.Background(), rawVal, options.Encrypt().SetAlgorithm(deterministicAlgorithm).SetKeyAltName(keyAltName)) assert.Nil(mt, err, "Encrypt error while encrypting value by alt key name: %v", err) assert.Equal(mt, encryptedValueSubtype, altEncrypted.Subtype, "expected encrypted value subtype %v, got %v", encryptedValueSubtype, altEncrypted.Subtype) assert.Equal(mt, encrypted.Data, altEncrypted.Data, "expected data %v, got %v", encrypted.Data, altEncrypted.Data) // insert an encrypted value for an auto-encrypted field _, err = cpt.cseColl.InsertOne(context.Background(), bson.D{{"encrypted_placeholder", encrypted}}) assert.NotNil(mt, err, "expected InsertOne error, got nil") }) } }) mt.RunOpts("3. external key vault", noClientOpts, func(mt mtest.T) { testCases := []struct { name string externalVault bool }{ {"with external vault", true}, {"without external vault", false}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { // setup options structs kmsProviders := map[string]map[string]interface{}{ "local": { "key": localMasterKey, }, } schemaMap := map[string]interface{}{"db.coll": readJSONFile(mt, "external-schema.json")} aeo := options.AutoEncryption(). SetKmsProviders(kmsProviders). SetKeyVaultNamespace(kvNamespace). SetSchemaMap(schemaMap). SetExtraOptions(getCryptSharedLibExtraOptions()) ceo := options.ClientEncryption(). SetKmsProviders(kmsProviders). SetKeyVaultNamespace(kvNamespace) kvClientOpts := defaultKvClientOptions if tc.externalVault { externalKvOpts := options.Client().ApplyURI(mtest.ClusterURI()).SetAuth(options.Credential{ Username: "fake-user", Password: "fake-password", }) integtest.AddTestServerAPIVersion(externalKvOpts) aeo.SetKeyVaultClientOptions(externalKvOpts) kvClientOpts = externalKvOpts } cpt := setup(mt, aeo, kvClientOpts, ceo) defer cpt.teardown(mt) // manually insert data key key := readJSONFile(mt, "external-key.json") _, err := cpt.keyVaultColl.InsertOne(context.Background(), key) assert.Nil(mt, err, "InsertOne error for data key: %v", err) subtype, data := key.Lookup("_id").Binary() dataKeyID := primitive.Binary{Subtype: subtype, Data: data} doc := bson.D{{"encrypted", "test"}} _, insertErr := cpt.cseClient.Database("db").Collection("coll").InsertOne(context.Background(), doc) rawVal := bson.RawValue{Type: bson.TypeString, Value: bsoncore.AppendString(nil, "test")} _, encErr := cpt.clientEnc.Encrypt(context.Background(), rawVal, options.Encrypt().SetKeyID(dataKeyID).SetAlgorithm(deterministicAlgorithm)) if tc.externalVault { assert.NotNil(mt, insertErr, "expected InsertOne auth error, got nil") assert.NotNil(mt, encErr, "expected Encrypt auth error, got nil") assert.True(mt, strings.Contains(insertErr.Error(), "auth error"), "expected InsertOne auth error, got %v", insertErr) assert.True(mt, strings.Contains(encErr.Error(), "auth error"), "expected Encrypt auth error, got %v", insertErr) return } assert.Nil(mt, insertErr, "InsertOne error: %v", insertErr) assert.Nil(mt, encErr, "Encrypt error: %v", err) }) } }) mt.Run("4. bson size limits", func(mt mtest.T) { kmsProviders := map[string]map[string]interface{}{ "local": { "key": localMasterKey, }, } aeo := options.AutoEncryption(). SetKmsProviders(kmsProviders). SetKeyVaultNamespace(kvNamespace). SetExtraOptions(getCryptSharedLibExtraOptions()) cpt := setup(mt, aeo, nil, nil) defer cpt.teardown(mt) // create coll with JSON schema err := mt.Client.Database("db").RunCommand(context.Background(), bson.D{ {"create", "coll"}, {"validator", bson.D{ {"$jsonSchema", readJSONFile(mt, "limits-schema.json")}, }}, }).Err() assert.Nil(mt, err, "create error with validator: %v", err) // insert key key := readJSONFile(mt, "limits-key.json") _, err = cpt.keyVaultColl.InsertOne(context.Background(), key) assert.Nil(mt, err, "InsertOne error for key: %v", err) var builder2mb, builder16mb strings.Builder for i := 0; i < cryptMaxBatchSizeBytes; i++ { builder2mb.WriteByte('a') } for i := 0; i < maxBsonObjSize; i++ { builder16mb.WriteByte('a') } complete2mbStr := builder2mb.String() complete16mbStr := builder16mb.String() // insert a document over 2MiB doc := bson.D{{"over_2mib_under_16mib", complete2mbStr}} _, err = cpt.cseColl.InsertOne(context.Background(), doc) assert.Nil(mt, err, "InsertOne error for 2MiB document: %v", err) str := complete2mbStr[:cryptMaxBatchSizeBytes-2000] // remove last 2000 bytes limitsDoc := readJSONFile(mt, "limits-doc.json") // insert a doc smaller than 2MiB that is bigger than 2MiB after encryption var extendedLimitsDoc []byte extendedLimitsDoc = append(extendedLimitsDoc, limitsDoc...) extendedLimitsDoc = extendedLimitsDoc[:len(extendedLimitsDoc)-1] // remove last byte to add new fields extendedLimitsDoc = bsoncore.AppendStringElement(extendedLimitsDoc, "_id", "encryption_exceeds_2mib") extendedLimitsDoc = bsoncore.AppendStringElement(extendedLimitsDoc, "unencrypted", str) extendedLimitsDoc, _ = bsoncore.AppendDocumentEnd(extendedLimitsDoc, 0) _, err = cpt.cseColl.InsertOne(context.Background(), extendedLimitsDoc) assert.Nil(mt, err, "error inserting extended limits document: %v", err) // bulk insert two 2MiB documents, each over 2 MiB // each document should be split into its own batch because the documents are bigger than 2MiB but smaller // than 16MiB cpt.cseStarted = cpt.cseStarted[:0] firstDoc := bson.D{{"_id", "over_2mib_1"}, {"unencrypted", complete2mbStr}} secondDoc := bson.D{{"_id", "over_2mib_2"}, {"unencrypted", complete2mbStr}} _, err = cpt.cseColl.InsertMany(context.Background(), []interface{}{firstDoc, secondDoc}) assert.Nil(mt, err, "InsertMany error for small documents: %v", err) assert.Equal(mt, 2, len(cpt.cseStarted), "expected 2 insert events, got %d", len(cpt.cseStarted)) // bulk insert two documents str = complete2mbStr[:cryptMaxBatchSizeBytes-20000] firstBulkDoc := make([]byte, len(limitsDoc)) copy(firstBulkDoc, limitsDoc) firstBulkDoc = firstBulkDoc[:len(firstBulkDoc)-1] // remove last byte to append new fields firstBulkDoc = bsoncore.AppendStringElement(firstBulkDoc, "_id", "encryption_exceeds_2mib_1") firstBulkDoc = bsoncore.AppendStringElement(firstBulkDoc, "unencrypted", string(str)) firstBulkDoc, _ = bsoncore.AppendDocumentEnd(firstBulkDoc, 0) secondBulkDoc := make([]byte, len(limitsDoc)) copy(secondBulkDoc, limitsDoc) secondBulkDoc = secondBulkDoc[:len(secondBulkDoc)-1] // remove last byte to append new fields secondBulkDoc = bsoncore.AppendStringElement(secondBulkDoc, "_id", "encryption_exceeds_2mib_2") secondBulkDoc = bsoncore.AppendStringElement(secondBulkDoc, "unencrypted", string(str)) secondBulkDoc, _ = bsoncore.AppendDocumentEnd(secondBulkDoc, 0) cpt.cseStarted = cpt.cseStarted[:0] _, err = cpt.cseColl.InsertMany(context.Background(), []interface{}{firstBulkDoc, secondBulkDoc}) assert.Nil(mt, err, "InsertMany error for large documents: %v", err) assert.Equal(mt, 2, len(cpt.cseStarted), "expected 2 insert events, got %d", len(cpt.cseStarted)) // insert a document slightly smaller than 16MiB and expect the operation to succeed doc = bson.D{{"_id", "under_16mib"}, {"unencrypted", complete16mbStr[:maxBsonObjSize-2000]}} _, err = cpt.cseColl.InsertOne(context.Background(), doc) assert.Nil(mt, err, "InsertOne error: %v", err) // insert a document over 16MiB and expect the operation to fail var over16mb []byte over16mb = append(over16mb, limitsDoc...) over16mb = over16mb[:len(over16mb)-1] // remove last byte over16mb = bsoncore.AppendStringElement(over16mb, "_id", "encryption_exceeds_16mib") over16mb = bsoncore.AppendStringElement(over16mb, "unencrypted", complete16mbStr[:maxBsonObjSize-2000]) over16mb, _ = bsoncore.AppendDocumentEnd(over16mb, 0) _, err = cpt.cseColl.InsertOne(context.Background(), over16mb) assert.NotNil(mt, err, "expected InsertOne error for document over 16MiB, got nil") }) mt.Run("5. views are prohibited", func(mt mtest.T) { mt.Parallel() kmsProviders := map[string]map[string]interface{}{ "local": { "key": localMasterKey, }, } aeo := options.AutoEncryption(). SetKmsProviders(kmsProviders). SetKeyVaultNamespace(kvNamespace). SetExtraOptions(getCryptSharedLibExtraOptions()) cpt := setup(mt, aeo, nil, nil) defer cpt.teardown(mt) // create view on db.coll mt.CreateCollection(mtest.Collection{ Name: "view", DB: cpt.cseColl.Database().Name(), ViewOn: "coll", ViewPipeline: mongo.Pipeline{}, }, true) view := cpt.cseColl.Database().Collection("view") _, err := view.InsertOne(context.Background(), bson.D{{"_id", "insert_on_view"}}) assert.NotNil(mt, err, "expected InsertOne error on view, got nil") errStr := strings.ToLower(err.Error()) viewErrSubstr := "cannot auto encrypt a view" assert.True(mt, strings.Contains(errStr, viewErrSubstr), "expected error '%v' to contain substring '%v'", errStr, viewErrSubstr) }) mt.RunOpts("6. corpus test", noClientOpts, func(mt mtest.T) { if "" == os.Getenv("KMS_MOCK_SERVERS_RUNNING") { mt.Skipf("Skipping test as KMS_MOCK_SERVERS_RUNNING is not set") } corpusSchema := readJSONFile(mt, "corpus-schema.json") localSchemaMap := map[string]interface{}{ "db.coll": corpusSchema, } tlsConfig := make(map[string]tls.Config) if tlsCAFileKMIP != "" && tlsClientCertificateKeyFileKMIP != "" { tlsOpts := map[string]interface{}{ "tlsCertificateKeyFile": tlsClientCertificateKeyFileKMIP, "tlsCAFile": tlsCAFileKMIP, } kmipConfig, err := options.BuildTLSConfig(tlsOpts) assert.Nil(mt, err, "BuildTLSConfig error: %v", err) tlsConfig["kmip"] = kmipConfig } getBaseAutoEncryptionOpts := func() options.AutoEncryptionOptions { return options.AutoEncryption(). SetKmsProviders(fullKmsProvidersMap). SetKeyVaultNamespace(kvNamespace). SetTLSConfig(tlsConfig). SetExtraOptions(getCryptSharedLibExtraOptions()) } testCases := []struct { name string aeo options.AutoEncryptionOptions schema bson.Raw // the schema to create the collection. if nil, the collection won't be explicitly created }{ {"remote schema", getBaseAutoEncryptionOpts(), corpusSchema}, {"local schema", getBaseAutoEncryptionOpts().SetSchemaMap(localSchemaMap), nil}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { ceo := options.ClientEncryption(). SetKmsProviders(fullKmsProvidersMap). SetKeyVaultNamespace(kvNamespace). SetTLSConfig(tlsConfig) cpt := setup(mt, tc.aeo, defaultKvClientOptions, ceo) defer cpt.teardown(mt) // create collection with JSON schema if tc.schema != nil { db := cpt.coll.Database() err := db.RunCommand(context.Background(), bson.D{ {"create", "coll"}, {"validator", bson.D{ {"$jsonSchema", readJSONFile(mt, "corpus-schema.json")}, }}, }).Err() assert.Nil(mt, err, "create error with validator: %v", err) } // Manually insert keys for each KMS provider into the key vault. _, err := cpt.keyVaultColl.InsertMany(context.Background(), []interface{}{ readJSONFile(mt, "corpus-key-local.json"), readJSONFile(mt, "corpus-key-aws.json"), readJSONFile(mt, "corpus-key-azure.json"), readJSONFile(mt, "corpus-key-gcp.json"), readJSONFile(mt, "corpus-key-kmip.json"), }) assert.Nil(mt, err, "InsertMany error for key vault: %v", err) // read original corpus and recursively copy over each value to new corpus, encrypting certain values // when needed corpus := readJSONFile(mt, "corpus.json") cidx, copied := bsoncore.AppendDocumentStart(nil) elems, _ := corpus.Elements() // Keys for top-level non-document elements that should be copied directly. copiedKeys := map[string]struct{}{ "_id": {}, "altname_aws": {}, "altname_local": {}, "altname_azure": {}, "altname_gcp": {}, "altname_kmip": {}, } for _, elem := range elems { key := elem.Key() val := elem.Value() if _, ok := copiedKeys[key]; ok { copied = bsoncore.AppendStringElement(copied, key, val.StringValue()) continue } doc := val.Document() switch method := doc.Lookup("method").StringValue(); method { case "auto": // Copy the value directly because it will be auto-encrypted later. copied = bsoncore.AppendDocumentElement(copied, key, doc) continue case "explicit": // Handled below. default: mt.Fatalf("unrecognized 'method' value %q", method) } // explicitly encrypt value algorithm := deterministicAlgorithm if doc.Lookup("algo").StringValue() == "rand" { algorithm = randomAlgorithm } eo := options.Encrypt().SetAlgorithm(algorithm) identifier := doc.Lookup("identifier").StringValue() kms := doc.Lookup("kms").StringValue() switch identifier { case "id": var keyID string switch kms { case "local": keyID = "LOCALAAAAAAAAAAAAAAAAA==" case "aws": keyID = "AWSAAAAAAAAAAAAAAAAAAA==" case "azure": keyID = "AZUREAAAAAAAAAAAAAAAAA==" case "gcp": keyID = "GCPAAAAAAAAAAAAAAAAAAA==" case "kmip": keyID = "KMIPAAAAAAAAAAAAAAAAAA==" default: mt.Fatalf("unrecognized KMS provider %q", kms) } keyIDBytes, err := base64.StdEncoding.DecodeString(keyID) assert.Nil(mt, err, "base64 DecodeString error: %v", err) eo.SetKeyID(primitive.Binary{Subtype: 4, Data: keyIDBytes}) case "altname": eo.SetKeyAltName(kms) // alt name for a key is the same as the KMS name default: mt.Fatalf("unrecognized identifier: %v", identifier) } // iterate over all elements in the document. copy elements directly, except for ones that need to // be encrypted, which should be copied after encryption. var nestedIdx int32 nestedIdx, copied = bsoncore.AppendDocumentElementStart(copied, key) docElems, _ := doc.Elements() for _, de := range docElems { deKey := de.Key() deVal := de.Value() // element to encrypt has key "value" if deKey != "value" { copied = bsoncore.AppendValueElement(copied, deKey, rawValueToCoreValue(deVal)) continue } encrypted, err := cpt.clientEnc.Encrypt(context.Background(), deVal, eo) if !doc.Lookup("allowed").Boolean() { // if allowed is false, encryption should error. in this case, the unencrypted value should be // copied over assert.NotNil(mt, err, "expected error encrypting value for key %v, got nil", key) copied = bsoncore.AppendValueElement(copied, deKey, rawValueToCoreValue(deVal)) continue } // copy encrypted value assert.Nil(mt, err, "Encrypt error for key %v: %v", key, err) copied = bsoncore.AppendBinaryElement(copied, deKey, encrypted.Subtype, encrypted.Data) } copied, _ = bsoncore.AppendDocumentEnd(copied, nestedIdx) } copied, _ = bsoncore.AppendDocumentEnd(copied, cidx) // insert document with encrypted values _, err = cpt.cseColl.InsertOne(context.Background(), copied) assert.Nil(mt, err, "InsertOne error for corpus document: %v", err) // find document using client with encryption and assert it matches original decryptedDoc, err := cpt.cseColl.FindOne(context.Background(), bson.D{}).Raw() assert.Nil(mt, err, "Find error with encrypted client: %v", err) assert.Equal(mt, corpus, decryptedDoc, "expected document %v, got %v", corpus, decryptedDoc) // find document using a client without encryption enabled and assert fields remain encrypted corpusEncrypted := readJSONFile(mt, "corpus-encrypted.json") foundDoc, err := cpt.coll.FindOne(context.Background(), bson.D{}).Raw() assert.Nil(mt, err, "Find error with unencrypted client: %v", err) encryptedElems, _ := corpusEncrypted.Elements() for _, encryptedElem := range encryptedElems { // skip non-document fields encryptedDoc, ok := encryptedElem.Value().DocumentOK() if !ok { continue } allowed := encryptedDoc.Lookup("allowed").Boolean() expectedKey := encryptedElem.Key() expectedVal := encryptedDoc.Lookup("value") foundVal := foundDoc.Lookup(expectedKey).Document().Lookup("value") // for deterministic encryption, the value should be exactly equal // for random encryption, the value should not be equal if allowed is true algo := encryptedDoc.Lookup("algo").StringValue() switch algo { case "det": assert.True(mt, expectedVal.Equal(foundVal), "expected value %v for key %v, got %v", expectedVal, expectedKey, foundVal) case "rand": if allowed { assert.False(mt, expectedVal.Equal(foundVal), "expected values for key %v to be different but were %v", expectedKey, expectedVal) } } // if allowed is true, decrypt both values with clientEnc and validate equality if allowed { sub, data := expectedVal.Binary() expectedDecrypted, err := cpt.clientEnc.Decrypt(context.Background(), primitive.Binary{Subtype: sub, Data: data}) assert.Nil(mt, err, "Decrypt error: %v", err) sub, data = foundVal.Binary() actualDecrypted, err := cpt.clientEnc.Decrypt(context.Background(), primitive.Binary{Subtype: sub, Data: data}) assert.Nil(mt, err, "Decrypt error: %v", err) assert.True(mt, expectedDecrypted.Equal(actualDecrypted), "expected decrypted value %v for key %v, got %v", expectedDecrypted, expectedKey, actualDecrypted) continue } // if allowed is false, validate found value equals the original value in corpus corpusVal := corpus.Lookup(expectedKey).Document().Lookup("value") assert.True(mt, corpusVal.Equal(foundVal), "expected value %v for key %v, got %v", corpusVal, expectedKey, foundVal) } }) } }) mt.Run("7. custom endpoint", func(mt mtest.T) { validKmsProviders := map[string]map[string]interface{}{ "aws": { "accessKeyId": awsAccessKeyID, "secretAccessKey": awsSecretAccessKey, }, "azure": { "tenantId": azureTenantID, "clientId": azureClientID, "clientSecret": azureClientSecret, "identityPlatformEndpoint": "login.microsoftonline.com:443", }, "gcp": { "email": gcpEmail, "privateKey": gcpPrivateKey, "endpoint": "oauth2.googleapis.com:443", }, "kmip": { "endpoint": "localhost:5698", }, } tlsConfig := make(map[string]tls.Config) if tlsCAFileKMIP != "" && tlsClientCertificateKeyFileKMIP != "" { tlsOpts := map[string]interface{}{ "tlsCertificateKeyFile": tlsClientCertificateKeyFileKMIP, "tlsCAFile": tlsCAFileKMIP, } kmipConfig, err := options.BuildTLSConfig(tlsOpts) assert.Nil(mt, err, "BuildTLSConfig error: %v", err) tlsConfig["kmip"] = kmipConfig } validClientEncryptionOptions := options.ClientEncryption(). SetKmsProviders(validKmsProviders). SetKeyVaultNamespace(kvNamespace). SetTLSConfig(tlsConfig) invalidKmsProviders := map[string]map[string]interface{}{ "azure": { "tenantId": azureTenantID, "clientId": azureClientID, "clientSecret": azureClientSecret, "identityPlatformEndpoint": "doesnotexist.invalid:443", }, "gcp": { "email": gcpEmail, "privateKey": gcpPrivateKey, "endpoint": "doesnotexist.invalid:443", }, "kmip": { "endpoint": "doesnotexist.local:5698", }, } invalidClientEncryptionOptions := options.ClientEncryption(). SetKmsProviders(invalidKmsProviders). SetKeyVaultNamespace(kvNamespace). SetTLSConfig(tlsConfig) awsSuccessWithoutEndpoint := map[string]interface{}{ "region": "us-east-1", "key": "arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0", } awsSuccessWithEndpoint := map[string]interface{}{ "region": "us-east-1", "key": "arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0", "endpoint": "kms.us-east-1.amazonaws.com", } awsSuccessWithHTTPSEndpoint := map[string]interface{}{ "region": "us-east-1", "key": "arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0", "endpoint": "kms.us-east-1.amazonaws.com:443", } awsFailureConnectionError := map[string]interface{}{ "region": "us-east-1", "key": "arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0", "endpoint": "kms.us-east-1.amazonaws.com:12345", } awsFailureInvalidEndpoint := map[string]interface{}{ "region": "us-east-1", "key": "arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0", "endpoint": "kms.us-east-2.amazonaws.com", } awsFailureParseError := map[string]interface{}{ "region": "us-east-1", "key": "arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0", "endpoint": "doesnotexist.invalid", } azure := map[string]interface{}{ "keyVaultEndpoint": "key-vault-csfle.vault.azure.net", "keyName": "key-name-csfle", } gcpSuccess := map[string]interface{}{ "projectId": "devprod-drivers", "location": "global", "keyRing": "key-ring-csfle", "keyName": "key-name-csfle", "endpoint": "cloudkms.googleapis.com:443", } gcpFailure := map[string]interface{}{ "projectId": "devprod-drivers", "location": "global", "keyRing": "key-ring-csfle", "keyName": "key-name-csfle", "endpoint": "doesnotexist.invalid:443", } kmipSuccessWithoutEndpoint := map[string]interface{}{ "keyId": "1", } kmipSuccessWithEndpoint := map[string]interface{}{ "keyId": "1", "endpoint": "localhost:5698", } kmipFailureInvalidEndpoint := map[string]interface{}{ "keyId": "1", "endpoint": "doesnotexist.local:5698", } const ( errConnectionRefused = "connection refused" errInvalidKMSResponse = "Invalid KMS response" errMongocryptError = "mongocrypt error" errNoSuchHost = "no such host" errServerMisbehaving = "server misbehaving" errWindowsTLSConnectionRefused = "No connection could be made because the target machine actively refused it" ) testCases := []struct { name string provider string masterKey interface{} errorSubstring []string testInvalidClientEncryption bool invalidClientEncryptionErrorSubstring []string }{ { name: "Case 1: aws success without endpoint", provider: "aws", masterKey: awsSuccessWithoutEndpoint, errorSubstring: []string{}, testInvalidClientEncryption: false, invalidClientEncryptionErrorSubstring: []string{}, }, { name: "Case 2: aws success with endpoint", provider: "aws", masterKey: awsSuccessWithEndpoint, errorSubstring: []string{}, testInvalidClientEncryption: false, invalidClientEncryptionErrorSubstring: []string{}, }, { name: "Case 3: aws success with https endpoint", provider: "aws", masterKey: awsSuccessWithHTTPSEndpoint, errorSubstring: []string{}, testInvalidClientEncryption: false, invalidClientEncryptionErrorSubstring: []string{}, }, { name: "Case 4: aws failure with connection error", provider: "aws", masterKey: awsFailureConnectionError, errorSubstring: []string{errConnectionRefused, errWindowsTLSConnectionRefused}, testInvalidClientEncryption: false, invalidClientEncryptionErrorSubstring: []string{}, }, { name: "Case 5: aws failure with wrong endpoint", provider: "aws", masterKey: awsFailureInvalidEndpoint, errorSubstring: []string{errMongocryptError}, testInvalidClientEncryption: false, invalidClientEncryptionErrorSubstring: []string{}, }, { name: "Case 6: aws failure with parse error", provider: "aws", masterKey: awsFailureParseError, errorSubstring: []string{errNoSuchHost, errServerMisbehaving}, testInvalidClientEncryption: false, invalidClientEncryptionErrorSubstring: []string{}, }, { name: "Case 7: azure success", provider: "azure", masterKey: azure, errorSubstring: []string{}, testInvalidClientEncryption: true, invalidClientEncryptionErrorSubstring: []string{errNoSuchHost, errServerMisbehaving}, }, { name: "Case 8: gcp success", provider: "gcp", masterKey: gcpSuccess, errorSubstring: []string{}, testInvalidClientEncryption: true, invalidClientEncryptionErrorSubstring: []string{errNoSuchHost, errServerMisbehaving}, }, { name: "Case 9: gcp failure", provider: "gcp", masterKey: gcpFailure, errorSubstring: []string{errInvalidKMSResponse}, testInvalidClientEncryption: false, invalidClientEncryptionErrorSubstring: []string{}, }, { name: "Case 10: kmip success without endpoint", provider: "kmip", masterKey: kmipSuccessWithoutEndpoint, errorSubstring: []string{}, testInvalidClientEncryption: true, invalidClientEncryptionErrorSubstring: []string{errNoSuchHost, errServerMisbehaving}, }, { name: "Case 11: kmip success with endpoint", provider: "kmip", masterKey: kmipSuccessWithEndpoint, errorSubstring: []string{}, testInvalidClientEncryption: false, invalidClientEncryptionErrorSubstring: []string{}, }, { name: "Case 12: kmip failure with invalid endpoint", provider: "kmip", masterKey: kmipFailureInvalidEndpoint, errorSubstring: []string{errNoSuchHost, errServerMisbehaving}, testInvalidClientEncryption: false, invalidClientEncryptionErrorSubstring: []string{}, }, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { if strings.Contains(tc.name, "kmip") && "" == os.Getenv("KMS_MOCK_SERVERS_RUNNING") { mt.Skipf("Skipping test as KMS_MOCK_SERVERS_RUNNING is not set") } cpt := setup(mt, nil, defaultKvClientOptions, validClientEncryptionOptions) defer cpt.teardown(mt) dkOpts := options.DataKey().SetMasterKey(tc.masterKey) createdKey, err := cpt.clientEnc.CreateDataKey(context.Background(), tc.provider, dkOpts) if len(tc.errorSubstring) > 0 { assert.NotNil(mt, err, "expected error, got nil") assert.True(t, containsSubstring(tc.errorSubstring, err.Error()), "expected tc.errorSubstring=%v to contain %v, but it didn't", tc.errorSubstring, err.Error()) return } assert.Nil(mt, err, "CreateDataKey error: %v", err) encOpts := options.Encrypt().SetKeyID(createdKey).SetAlgorithm(deterministicAlgorithm) testVal := bson.RawValue{ Type: bson.TypeString, Value: bsoncore.AppendString(nil, "test"), } encrypted, err := cpt.clientEnc.Encrypt(context.Background(), testVal, encOpts) assert.Nil(mt, err, "Encrypt error: %v", err) decrypted, err := cpt.clientEnc.Decrypt(context.Background(), encrypted) assert.Nil(mt, err, "Decrypt error: %v", err) assert.Equal(mt, testVal, decrypted, "expected value %s, got %s", testVal, decrypted) if !tc.testInvalidClientEncryption { return } invalidClientEncryption, err := mongo.NewClientEncryption(cpt.kvClient, invalidClientEncryptionOptions) assert.Nil(mt, err, "error creating invalidClientEncryption object: %v", err) defer invalidClientEncryption.Close(context.Background()) invalidKeyOpts := options.DataKey().SetMasterKey(tc.masterKey) _, err = invalidClientEncryption.CreateDataKey(context.Background(), tc.provider, invalidKeyOpts) assert.NotNil(mt, err, "expected CreateDataKey error, got nil") assert.True(t, containsSubstring(tc.invalidClientEncryptionErrorSubstring, err.Error()), "expected tc.invalidClientEncryptionErrorSubstring=%v to contain %v, but it didn't", tc.invalidClientEncryptionErrorSubstring, err.Error()) }) } }) mt.RunOpts("8. bypass mongocryptd spawning", noClientOpts, func(mt mtest.T) { mt.Parallel() kmsProviders := map[string]map[string]interface{}{ "local": { "key": localMasterKey, }, } schemaMap := map[string]interface{}{ "db.coll": readJSONFile(mt, "external-schema.json"), } // All mongocryptd options use port 27021 instead of the default 27020 to avoid interference // with mongocryptd instances spawned by previous tests. Explicitly disable loading the // crypt_shared library to make sure we're testing mongocryptd spawning behavior that is not // influenced by loading the crypt_shared library. mongocryptdBypassSpawnTrue := map[string]interface{}{ "mongocryptdBypassSpawn": true, "mongocryptdURI": "mongodb://localhost:27021/db?serverSelectionTimeoutMS=1000", "mongocryptdSpawnArgs": []string{"--pidfilepath=bypass-spawning-mongocryptd.pid", "--port=27021"}, "__cryptSharedLibDisabledForTestOnly": true, // Disable loading the crypt_shared library. } mongocryptdBypassSpawnFalse := map[string]interface{}{ "mongocryptdBypassSpawn": false, "mongocryptdSpawnArgs": []string{"--pidfilepath=bypass-spawning-mongocryptd.pid", "--port=27021"}, "__cryptSharedLibDisabledForTestOnly": true, // Disable loading the crypt_shared library. } mongocryptdBypassSpawnNotSet := map[string]interface{}{ "mongocryptdSpawnArgs": []string{"--pidfilepath=bypass-spawning-mongocryptd.pid", "--port=27021"}, "__cryptSharedLibDisabledForTestOnly": true, // Disable loading the crypt_shared library. } testCases := []struct { name string mongocryptdOpts map[string]interface{} setBypassAutoEncryption bool bypassAutoEncryption bool bypassQueryAnalysis bool useSharedLib bool }{ { name: "mongocryptdBypassSpawn only", mongocryptdOpts: mongocryptdBypassSpawnTrue, }, { name: "bypassAutoEncryption only", mongocryptdOpts: mongocryptdBypassSpawnNotSet, setBypassAutoEncryption: true, bypassAutoEncryption: true, }, { name: "mongocryptdBypassSpawn false, bypassAutoEncryption true", mongocryptdOpts: mongocryptdBypassSpawnFalse, setBypassAutoEncryption: true, bypassAutoEncryption: true, }, { name: "mongocryptdBypassSpawn true, bypassAutoEncryption false", mongocryptdOpts: mongocryptdBypassSpawnTrue, setBypassAutoEncryption: true, bypassAutoEncryption: false, }, { name: "bypassQueryAnalysis only", mongocryptdOpts: mongocryptdBypassSpawnNotSet, bypassQueryAnalysis: true, }, { name: "use shared library", useSharedLib: true, mongocryptdOpts: map[string]interface{}{ "mongocryptdURI": "mongodb://localhost:27021/db?serverSelectionTimeoutMS=1000", "mongocryptdSpawnArgs": []string{"--pidfilepath=bypass-spawning-mongocryptd.pid", "--port=27021"}, "cryptSharedLibPath": os.Getenv("CRYPT_SHARED_LIB_PATH"), "cryptSharedRequired": true, }, }, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { if tc.useSharedLib && os.Getenv("CRYPT_SHARED_LIB_PATH") == "" { mt.Skip("CRYPT_SHARED_LIB_PATH not set, skipping") return } aeo := options.AutoEncryption(). SetKmsProviders(kmsProviders). SetKeyVaultNamespace(kvNamespace). SetSchemaMap(schemaMap). SetExtraOptions(tc.mongocryptdOpts) if tc.setBypassAutoEncryption { aeo.SetBypassAutoEncryption(tc.bypassAutoEncryption) } aeo.SetBypassQueryAnalysis(tc.bypassQueryAnalysis) cpt := setup(mt, aeo, nil, nil) defer cpt.teardown(mt) _, err := cpt.cseColl.InsertOne(context.Background(), bson.D{{"unencrypted", "test"}}) // Check for mongocryptd server selection error if auto encryption needed mongocryptd. if !(tc.setBypassAutoEncryption && tc.bypassAutoEncryption) && !tc.bypassQueryAnalysis && !tc.useSharedLib { assert.NotNil(mt, err, "expected InsertOne error, got nil") mcryptErr, ok := err.(mongo.MongocryptdError) assert.True(mt, ok, "expected error type %T, got %v of type %T", mongo.MongocryptdError{}, err, err) assert.True(mt, strings.Contains(mcryptErr.Error(), "server selection error"), "expected mongocryptd server selection error, got %v", err) return } // If mongocryptd was not needed, the command should succeed. Create a new client to connect to // mongocryptd and verify it is not running. assert.Nil(mt, err, "InsertOne error: %v", err) mcryptOpts := options.Client().ApplyURI("mongodb://localhost:27021"). SetServerSelectionTimeout(1 * time.Second) integtest.AddTestServerAPIVersion(mcryptOpts) mcryptClient, err := mongo.Connect(context.Background(), mcryptOpts) assert.Nil(mt, err, "mongocryptd Connect error: %v", err) err = mcryptClient.Database("admin").RunCommand(context.Background(), bson.D{{handshake.LegacyHelloLowercase, 1}}).Err() assert.NotNil(mt, err, "expected mongocryptd legacy hello error, got nil") assert.True(mt, strings.Contains(err.Error(), "server selection error"), "expected mongocryptd server selection error, got %v", err) }) } }) changeStreamOpts := mtest.NewOptions(). CreateClient(false). Topologies(mtest.ReplicaSet) mt.RunOpts("change streams", changeStreamOpts, func(mt mtest.T) { // Change streams can't easily fit into the spec test format because of their tailable nature, so there are two // prose tests for them instead: // // 1. Auto-encryption errors for Watch operations. Collection-level change streams error because the // $changeStream aggregation stage is not valid for encryption. Client and database-level streams error because // only collection-level operations are valid for encryption. // // 2. Events are automatically decrypted: If the Watch() is done with BypassAutoEncryption=true, the Watch // should succeed and subsequent getMore calls should decrypt documents when necessary. var testConfig struct { JSONSchema bson.Raw `bson:"json_schema"` KeyVaultData []bson.Raw `bson:"key_vault_data"` EncryptedDocument bson.Raw `bson:"encrypted_document"` DecryptedDocument bson.Raw `bson:"decrytped_document"` } decodeJSONFile(mt, "change-streams-test.json", &testConfig) schemaMap := map[string]interface{}{ "db.coll": testConfig.JSONSchema, } kmsProviders := map[string]map[string]interface{}{ "aws": { "accessKeyId": awsAccessKeyID, "secretAccessKey": awsSecretAccessKey, }, } testCases := []struct { name string streamType mongo.StreamType }{ {"client", mongo.ClientStream}, {"database", mongo.DatabaseStream}, {"collection", mongo.CollectionStream}, } mt.RunOpts("auto encryption errors", noClientOpts, func(mt mtest.T) { mt.Parallel() for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { autoEncryptionOpts := options.AutoEncryption(). SetKmsProviders(kmsProviders). SetKeyVaultNamespace(kvNamespace). SetSchemaMap(schemaMap). SetExtraOptions(getCryptSharedLibExtraOptions()) cpt := setup(mt, autoEncryptionOpts, nil, nil) defer cpt.teardown(mt) _, err := getWatcher(mt, tc.streamType, cpt).Watch(context.Background(), mongo.Pipeline{}) assert.NotNil(mt, err, "expected Watch error: %v", err) }) } }) mt.RunOpts("events are automatically decrypted", noClientOpts, func(mt mtest.T) { for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { autoEncryptionOpts := options.AutoEncryption(). SetKmsProviders(kmsProviders). SetKeyVaultNamespace(kvNamespace). SetSchemaMap(schemaMap). SetBypassAutoEncryption(true) cpt := setup(mt, autoEncryptionOpts, nil, nil) defer cpt.teardown(mt) // Insert key vault data so the key can be accessed when starting the change stream. insertDocuments(mt, cpt.keyVaultColl, testConfig.KeyVaultData) stream, err := getWatcher(mt, tc.streamType, cpt).Watch(context.Background(), mongo.Pipeline{}) assert.Nil(mt, err, "Watch error: %v", err) defer stream.Close(context.Background()) // Insert already encrypted data and verify that it is automatically decrypted by Next(). insertDocuments(mt, cpt.coll, []bson.Raw{testConfig.EncryptedDocument}) assert.True(mt, stream.Next(context.Background()), "expected Next to return true, got false") gotValue, err := stream.Current.LookupErr("fullDocument") assert.Nil(mt, err, "did not find fullDocument in stream.Current: %v", stream.Current) gotDocument := gotValue.Document() err = compareDocs(mt, testConfig.DecryptedDocument, gotDocument) assert.Nil(mt, err, "compareDocs error: %v", err) }) } }) }) mt.RunOpts("9. deadlock tests", noClientOpts, func(mt mtest.T) { testcases := []struct { description string maxPoolSize uint64 bypassAutoEncryption bool keyVaultClientSet bool clientEncryptedTopologyOpeningExpected int clientEncryptedCommandStartedExpected []startedEvent clientKeyVaultCommandStartedExpected []startedEvent }{ // In the following comments, "special auto encryption options" refers to the "bypassAutoEncryption" and // "keyVaultClient" options { // If the client has a limited maxPoolSize, and no special auto-encryption options are set, the // driver should create an internal Client for metadata/keyVault operations. "deadlock case 1", 1, false, false, 2, []startedEvent{{"listCollections", "db"}, {"find", "keyvault"}, {"insert", "db"}, {"find", "db"}}, nil, }, { // If the client has a limited maxPoolSize, and a keyVaultClient is set, the driver should create // an internal Client for metadata operations. "deadlock case 2", 1, false, true, 2, []startedEvent{{"listCollections", "db"}, {"insert", "db"}, {"find", "db"}}, []startedEvent{{"find", "keyvault"}}, }, { // If the client has a limited maxPoolSize, and a bypassAutomaticEncryption=true, the driver should // create an internal Client for keyVault operations. "deadlock case 3", 1, true, false, 2, []startedEvent{{"find", "db"}, {"find", "keyvault"}}, nil, }, { // If the client has a limited maxPoolSize, bypassAutomaticEncryption=true, and a keyVaultClient is set, // the driver should not create an internal Client. "deadlock case 4", 1, true, true, 1, []startedEvent{{"find", "db"}}, []startedEvent{{"find", "keyvault"}}, }, { // If the client has an unlimited maxPoolSize, and no special auto-encryption options are set, the // driver should reuse the client for metadata/keyVault operations "deadlock case 5", 0, false, false, 1, []startedEvent{{"listCollections", "db"}, {"listCollections", "keyvault"}, {"find", "keyvault"}, {"insert", "db"}, {"find", "db"}}, nil, }, { // If the client has an unlimited maxPoolSize, and a keyVaultClient is set, the driver should reuse the // client for metadata operations. "deadlock case 6", 0, false, true, 1, []startedEvent{{"listCollections", "db"}, {"insert", "db"}, {"find", "db"}}, []startedEvent{{"find", "keyvault"}}, }, { // If the client has an unlimited maxPoolSize, and bypassAutomaticEncryption=true, the driver should // reuse the client for keyVault operations "deadlock case 7", 0, true, false, 1, []startedEvent{{"find", "db"}, {"find", "keyvault"}}, nil, }, { // If the client has an unlimited maxPoolSize, bypassAutomaticEncryption=true, and a keyVaultClient is // set, the driver should not create an internal Client. "deadlock case 8", 0, true, true, 1, []startedEvent{{"find", "db"}}, []startedEvent{{"find", "keyvault"}}, }, } for _, tc := range testcases { mt.Run(tc.description, func(mt mtest.T) { var clientEncryptedEvents []startedEvent var clientEncryptedTopologyOpening int d := newDeadlockTest(mt) defer d.disconnect(mt) kmsProviders := map[string]map[string]interface{}{ "local": {"key": localMasterKey}, } aeOpts := options.AutoEncryption() aeOpts.SetKeyVaultNamespace("keyvault.datakeys"). SetKmsProviders(kmsProviders). SetBypassAutoEncryption(tc.bypassAutoEncryption) // Only set the crypt_shared library extra options if bypassAutoEncryption isn't // true because it's invalid to set cryptSharedLibRequired=true and // bypassAutoEncryption=true together. if !tc.bypassAutoEncryption { aeOpts.SetExtraOptions(getCryptSharedLibExtraOptions()) } if tc.keyVaultClientSet { integtest.AddTestServerAPIVersion(d.clientKeyVaultOpts) aeOpts.SetKeyVaultClientOptions(d.clientKeyVaultOpts) } ceOpts := options.Client().ApplyURI(mtest.ClusterURI()). SetMonitor(&event.CommandMonitor{ Started: func(ctx context.Context, event event.CommandStartedEvent) { clientEncryptedEvents = append(clientEncryptedEvents, startedEvent{event.CommandName, event.DatabaseName}) }, }). SetServerMonitor(&event.ServerMonitor{ TopologyOpening: func(event event.TopologyOpeningEvent) { clientEncryptedTopologyOpening++ }, }). SetMaxPoolSize(tc.maxPoolSize). SetAutoEncryptionOptions(aeOpts) integtest.AddTestServerAPIVersion(ceOpts) clientEncrypted, err := mongo.Connect(context.Background(), ceOpts) assert.Nil(mt, err, "Connect error: %v", err) defer clientEncrypted.Disconnect(context.Background()) coll := clientEncrypted.Database("db").Collection("coll") if !tc.bypassAutoEncryption { _, err = coll.InsertOne(context.Background(), bson.M{"_id": 0, "encrypted": "string0"}) } else { unencryptedColl := d.clientTest.Database("db").Collection("coll") _, err = unencryptedColl.InsertOne(context.Background(), bson.M{"_id": 0, "encrypted": d.ciphertext}) } assert.Nil(mt, err, "InsertOne error: %v", err) raw, err := coll.FindOne(context.Background(), bson.M{"_id": 0}).Raw() assert.Nil(mt, err, "FindOne error: %v", err) expected := bsoncore.NewDocumentBuilder(). AppendInt32("_id", 0). AppendString("encrypted", "string0"). Build() assert.Equal(mt, bson.Raw(expected), raw, "returned value unequal, expected: %v, got: %v", expected, raw) assert.Equal(mt, clientEncryptedEvents, tc.clientEncryptedCommandStartedExpected, "mismatched events for clientEncrypted. Expected %v, got %v", clientEncryptedEvents, tc.clientEncryptedCommandStartedExpected) assert.Equal(mt, d.clientKeyVaultEvents, tc.clientKeyVaultCommandStartedExpected, "mismatched events for clientKeyVault. Expected %v, got %v", d.clientKeyVaultEvents, tc.clientKeyVaultCommandStartedExpected) assert.Equal(mt, clientEncryptedTopologyOpening, tc.clientEncryptedTopologyOpeningExpected, "wrong number of TopologyOpening events. Expected %v, got %v", tc.clientEncryptedTopologyOpeningExpected, clientEncryptedTopologyOpening) }) } }) // These tests only run when 3 KMS HTTP servers and 1 KMS KMIP server are running. See specification for port numbers and necessary arguments: // https://github.com/mongodb/specifications/blob/master/source/client-side-encryption/tests/README.rst#kms-tls-options-tests mt.RunOpts("10. kms tls tests", noClientOpts, func(mt mtest.T) { kmsTlsTestcase := os.Getenv("KMS_TLS_TESTCASE") if kmsTlsTestcase == "" { mt.Skipf("Skipping test as KMS_TLS_TESTCASE is not set") } testcases := []struct { name string port int envValue string errMessage string }{ { "invalid certificate", 9000, "INVALID_CERT", "expired", }, { "invalid hostname", 9001, "INVALID_HOSTNAME", "SANs", }, } for _, tc := range testcases { mt.Run(tc.name, func(mt mtest.T) { // Only run test if correct KMS mock server is running. if kmsTlsTestcase != tc.envValue { mt.Skipf("Skipping test as KMS_TLS_TESTCASE is set to %q, expected %v", kmsTlsTestcase, tc.envValue) } ceo := options.ClientEncryption(). SetKmsProviders(fullKmsProvidersMap). SetKeyVaultNamespace(kvNamespace) cpt := setup(mt, nil, nil, ceo) defer cpt.teardown(mt) _, err := cpt.clientEnc.CreateDataKey(context.Background(), "aws", options.DataKey().SetMasterKey( bson.D{ {"region", "us-east-1"}, {"key", "arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0"}, {"endpoint", fmt.Sprintf("127.0.0.1:%d", tc.port)}, }, )) assert.NotNil(mt, err, "expected CreateDataKey error, got nil") assert.True(mt, strings.Contains(err.Error(), tc.errMessage), "expected CreateDataKey error to contain %v, got %v", tc.errMessage, err.Error()) }) } }) // These tests only run when 3 KMS HTTP servers and 1 KMS KMIP server are running. See specification for port numbers and necessary arguments: // https://github.com/mongodb/specifications/blob/master/source/client-side-encryption/tests/README.rst#kms-tls-options-tests mt.RunOpts("11. kms tls options tests", noClientOpts, func(mt mtest.T) { if os.Getenv("KMS_MOCK_SERVERS_RUNNING") == "" { mt.Skipf("Skipping test as KMS_MOCK_SERVERS_RUNNING is not set") } validKmsProviders := map[string]map[string]interface{}{ "aws": { "accessKeyId": awsAccessKeyID, "secretAccessKey": awsSecretAccessKey, }, "azure": { "tenantId": azureTenantID, "clientId": azureClientID, "clientSecret": azureClientSecret, "identityPlatformEndpoint": "127.0.0.1:9002", }, "gcp": { "email": gcpEmail, "privateKey": gcpPrivateKey, "endpoint": "127.0.0.1:9002", }, "kmip": { "endpoint": "127.0.0.1:5698", }, } expiredKmsProviders := map[string]map[string]interface{}{ "aws": { "accessKeyId": awsAccessKeyID, "secretAccessKey": awsSecretAccessKey, }, "azure": { "tenantId": azureTenantID, "clientId": azureClientID, "clientSecret": azureClientSecret, "identityPlatformEndpoint": "127.0.0.1:9000", }, "gcp": { "email": gcpEmail, "privateKey": gcpPrivateKey, "endpoint": "127.0.0.1:9000", }, "kmip": { "endpoint": "127.0.0.1:9000", }, } invalidKmsProviders := map[string]map[string]interface{}{ "aws": { "accessKeyId": awsAccessKeyID, "secretAccessKey": awsSecretAccessKey, }, "azure": { "tenantId": azureTenantID, "clientId": azureClientID, "clientSecret": azureClientSecret, "identityPlatformEndpoint": "127.0.0.1:9001", }, "gcp": { "email": gcpEmail, "privateKey": gcpPrivateKey, "endpoint": "127.0.0.1:9001", }, "kmip": { "endpoint": "127.0.0.1:9001", }, } // create valid Client Encryption options without a client certificate validClientEncryptionOptionsWithoutClientCert := options.ClientEncryption(). SetKmsProviders(validKmsProviders). SetKeyVaultNamespace(kvNamespace) // make TLS opts containing client certificate and CA file tlsConfig := make(map[string]tls.Config) if tlsCAFileKMIP != "" && tlsClientCertificateKeyFileKMIP != "" { clientAndCATlsMap := map[string]interface{}{ "tlsCertificateKeyFile": tlsClientCertificateKeyFileKMIP, "tlsCAFile": tlsCAFileKMIP, } certConfig, err := options.BuildTLSConfig(clientAndCATlsMap) assert.Nil(mt, err, "BuildTLSConfig error: %v", err) tlsConfig["aws"] = certConfig tlsConfig["azure"] = certConfig tlsConfig["gcp"] = certConfig tlsConfig["kmip"] = certConfig } // create valid Client Encryption options and set valid TLS options validClientEncryptionOptionsWithTLS := options.ClientEncryption(). SetKmsProviders(validKmsProviders). SetKeyVaultNamespace(kvNamespace). SetTLSConfig(tlsConfig) // make TLS opts containing only CA file if tlsCAFileKMIP != "" { caTlsMap := map[string]interface{}{ "tlsCAFile": tlsCAFileKMIP, } certConfig, err := options.BuildTLSConfig(caTlsMap) assert.Nil(mt, err, "BuildTLSConfig error: %v", err) tlsConfig["aws"] = certConfig tlsConfig["azure"] = certConfig tlsConfig["gcp"] = certConfig tlsConfig["kmip"] = certConfig } // create invalid Client Encryption options with expired credentials expiredClientEncryptionOptions := options.ClientEncryption(). SetKmsProviders(expiredKmsProviders). SetKeyVaultNamespace(kvNamespace). SetTLSConfig(tlsConfig) // create invalid Client Encryption options with invalid hostnames invalidHostnameClientEncryptionOptions := options.ClientEncryption(). SetKmsProviders(invalidKmsProviders). SetKeyVaultNamespace(kvNamespace). SetTLSConfig(tlsConfig) awsMasterKeyNoClientCert := map[string]interface{}{ "region": "us-east-1", "key": "arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0", "endpoint": "127.0.0.1:9002", } awsMasterKeyWithTLS := map[string]interface{}{ "region": "us-east-1", "key": "arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0", "endpoint": "127.0.0.1:9002", } awsMasterKeyExpired := map[string]interface{}{ "region": "us-east-1", "key": "arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0", "endpoint": "127.0.0.1:9000", } awsMasterKeyInvalidHostname := map[string]interface{}{ "region": "us-east-1", "key": "arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0", "endpoint": "127.0.0.1:9001", } azureMasterKey := map[string]interface{}{ "keyVaultEndpoint": "doesnotexist.local", "keyName": "foo", } gcpMasterKey := map[string]interface{}{ "projectId": "foo", "location": "bar", "keyRing": "baz", "keyName": "foo", } kmipMasterKey := map[string]interface{}{} testCases := []struct { name string masterKeyNoClientCert interface{} masterKeyWithTLS interface{} masterKeyExpired interface{} masterKeyInvalidHostname interface{} tlsError string expiredError string invalidHostnameError string }{ {"aws", awsMasterKeyNoClientCert, awsMasterKeyWithTLS, awsMasterKeyExpired, awsMasterKeyInvalidHostname, "parse error", "certificate has expired", "cannot validate certificate"}, {"azure", azureMasterKey, azureMasterKey, azureMasterKey, azureMasterKey, "HTTP status=404", "certificate has expired", "cannot validate certificate"}, {"gcp", gcpMasterKey, gcpMasterKey, gcpMasterKey, gcpMasterKey, "HTTP status=404", "certificate has expired", "cannot validate certificate"}, {"kmip", kmipMasterKey, kmipMasterKey, kmipMasterKey, kmipMasterKey, "", "certificate has expired", "cannot validate certificate"}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { if tc.name == "kmip" && "" == os.Getenv("KMS_MOCK_SERVERS_RUNNING") { mt.Skipf("Skipping test as KMS_MOCK_SERVERS_RUNNING is not set") } // call CreateDataKey with CEO no TLS with each provider and corresponding master key cpt := setup(mt, nil, defaultKvClientOptions, validClientEncryptionOptionsWithoutClientCert) defer cpt.teardown(mt) dkOpts := options.DataKey().SetMasterKey(tc.masterKeyNoClientCert) _, err := cpt.clientEnc.CreateDataKey(context.Background(), tc.name, dkOpts) assert.NotNil(mt, err, "expected error, got nil") assert.True(mt, strings.Contains(err.Error(), "certificate signed by unknown authority"), "expected error '%s' to contain '%s'", err.Error(), "certificate signed by unknown authority") // call CreateDataKey with CEO & TLS with each provider and corresponding master key cpt = setup(mt, nil, defaultKvClientOptions, validClientEncryptionOptionsWithTLS) dkOpts = options.DataKey().SetMasterKey(tc.masterKeyWithTLS) _, err = cpt.clientEnc.CreateDataKey(context.Background(), tc.name, dkOpts) // check if current test case is KMIP, which should pass if tc.name == "kmip" { assert.Nil(mt, err, "expected no error, got err: %v", err) } else { assert.NotNil(mt, err, "expected error, got nil") assert.True(mt, strings.Contains(err.Error(), tc.tlsError), "expected error '%s' to contain '%s'", err.Error(), tc.tlsError) } // call CreateDataKey with expired CEO each provider and same masterKey cpt = setup(mt, nil, defaultKvClientOptions, expiredClientEncryptionOptions) dkOpts = options.DataKey().SetMasterKey(tc.masterKeyExpired) _, err = cpt.clientEnc.CreateDataKey(context.Background(), tc.name, dkOpts) assert.NotNil(mt, err, "expected error, got nil") assert.True(mt, strings.Contains(err.Error(), tc.expiredError), "expected error '%s' to contain '%s'", err.Error(), tc.expiredError) // call CreateDataKey with invalid hostname CEO with each provider and same masterKey cpt = setup(mt, nil, defaultKvClientOptions, invalidHostnameClientEncryptionOptions) dkOpts = options.DataKey().SetMasterKey(tc.masterKeyInvalidHostname) _, err = cpt.clientEnc.CreateDataKey(context.Background(), tc.name, dkOpts) assert.NotNil(mt, err, "expected error, got nil") assert.True(mt, strings.Contains(err.Error(), tc.invalidHostnameError), "expected error '%s' to contain '%s'", err.Error(), tc.invalidHostnameError) }) } }) runOpts := mtest.NewOptions().MinServerVersion("7.0").Topologies(mtest.ReplicaSet, mtest.LoadBalanced, mtest.ShardedReplicaSet) // Only test MongoDB Server 7.0+. MongoDB Server 7.0 introduced a backwards breaking change to the Queryable Encryption (QE) protocol: QEv2. // libmongocrypt is configured to use the QEv2 protocol. mt.RunOpts("12. explicit encryption", runOpts, func(mt mtest.T) { // Test Setup ... begin encryptedFields := readJSONFile(mt, "encrypted-fields.json") key1Document := readJSONFile(mt, "key1-document.json") var key1ID primitive.Binary { subtype, data := key1Document.Lookup("_id").Binary() key1ID = primitive.Binary{Subtype: subtype, Data: data} } testSetup := func() (mongo.Client, mongo.ClientEncryption) { mtest.DropEncryptedCollection(mt, mt.Client.Database("db").Collection("explicit_encryption"), encryptedFields) cco := options.CreateCollection().SetEncryptedFields(encryptedFields) err := mt.Client.Database("db").CreateCollection(context.Background(), "explicit_encryption", cco) assert.Nil(mt, err, "error on CreateCollection: %v", err) err = mt.Client.Database("keyvault").Collection("datakeys").Drop(context.Background()) assert.Nil(mt, err, "error on Drop: %v", err) keyVaultClient, err := mongo.Connect(context.Background(), options.Client().ApplyURI(mtest.ClusterURI())) assert.Nil(mt, err, "error on Connect: %v", err) datakeysColl := keyVaultClient.Database("keyvault").Collection("datakeys", options.Collection().SetWriteConcern(mtest.MajorityWc)) _, err = datakeysColl.InsertOne(context.Background(), key1Document) assert.Nil(mt, err, "error on InsertOne: %v", err) // Create a ClientEncryption. ceo := options.ClientEncryption(). SetKeyVaultNamespace("keyvault.datakeys"). SetKmsProviders(fullKmsProvidersMap) clientEncryption, err := mongo.NewClientEncryption(keyVaultClient, ceo) assert.Nil(mt, err, "error on NewClientEncryption: %v", err) // Create a MongoClient with AutoEncryptionOpts and bypassQueryAnalysis=true. aeo := options.AutoEncryption(). SetKeyVaultNamespace("keyvault.datakeys"). SetKmsProviders(fullKmsProvidersMap). SetBypassQueryAnalysis(true) co := options.Client().SetAutoEncryptionOptions(aeo).ApplyURI(mtest.ClusterURI()) encryptedClient, err := mongo.Connect(context.Background(), co) assert.Nil(mt, err, "error on Connect: %v", err) return encryptedClient, clientEncryption } // Test Setup ... end mt.Run("case 1: can insert encrypted indexed and find", func(mt mtest.T) { encryptedClient, clientEncryption := testSetup() defer clientEncryption.Close(context.Background()) defer encryptedClient.Disconnect(context.Background()) // Explicit encrypt the value "encrypted indexed value" with algorithm: "Indexed". eo := options.Encrypt().SetAlgorithm("Indexed").SetKeyID(key1ID).SetContentionFactor(0) valueToEncrypt := "encrypted indexed value" rawVal := bson.RawValue{Type: bson.TypeString, Value: bsoncore.AppendString(nil, valueToEncrypt)} insertPayload, err := clientEncryption.Encrypt(context.Background(), rawVal, eo) assert.Nil(mt, err, "error in Encrypt: %v", err) // Insert. coll := encryptedClient.Database("db").Collection("explicit_encryption") _, err = coll.InsertOne(context.Background(), bson.D{{"_id", 1}, {"encryptedIndexed", insertPayload}}) assert.Nil(mt, err, "Error in InsertOne: %v", err) // Explicit encrypt an indexed value to find. eo = options.Encrypt().SetAlgorithm("Indexed").SetKeyID(key1ID).SetQueryType(options.QueryTypeEquality).SetContentionFactor(0) findPayload, err := clientEncryption.Encrypt(context.Background(), rawVal, eo) assert.Nil(mt, err, "error in Encrypt: %v", err) // Find. res := coll.FindOne(context.Background(), bson.D{{"encryptedIndexed", findPayload}}) assert.Nil(mt, res.Err(), "Error in FindOne: %v", res.Err()) got, err := res.Raw() assert.Nil(mt, err, "error in Raw: %v", err) gotValue, err := got.LookupErr("encryptedIndexed") assert.Nil(mt, err, "error in LookupErr: %v", err) assert.Equal(mt, gotValue.StringValue(), valueToEncrypt, "expected %q, got %q", valueToEncrypt, gotValue.StringValue()) }) mt.Run("case 2: can insert encrypted indexed and find with non-zero contention", func(mt mtest.T) { encryptedClient, clientEncryption := testSetup() defer clientEncryption.Close(context.Background()) defer encryptedClient.Disconnect(context.Background()) coll := encryptedClient.Database("db").Collection("explicit_encryption") valueToEncrypt := "encrypted indexed value" rawVal := bson.RawValue{Type: bson.TypeString, Value: bsoncore.AppendString(nil, valueToEncrypt)} for i := 0; i < 10; i++ { // Explicit encrypt the value "encrypted indexed value" with algorithm: "Indexed". eo := options.Encrypt().SetAlgorithm("Indexed").SetKeyID(key1ID).SetContentionFactor(10) insertPayload, err := clientEncryption.Encrypt(context.Background(), rawVal, eo) assert.Nil(mt, err, "error in Encrypt: %v", err) // Insert. _, err = coll.InsertOne(context.Background(), bson.D{{"_id", i}, {"encryptedIndexed", insertPayload}}) assert.Nil(mt, err, "Error in InsertOne: %v", err) } // Explicit encrypt an indexed value to find with default contentionFactor 0. { eo := options.Encrypt().SetAlgorithm("Indexed").SetKeyID(key1ID).SetQueryType(options.QueryTypeEquality).SetContentionFactor(0) findPayload, err := clientEncryption.Encrypt(context.Background(), rawVal, eo) assert.Nil(mt, err, "error in Encrypt: %v", err) // Find with contentionFactor=0. cursor, err := coll.Find(context.Background(), bson.D{{"encryptedIndexed", findPayload}}) assert.Nil(mt, err, "error in Find: %v", err) var got []bson.Raw err = cursor.All(context.Background(), &got) assert.Nil(mt, err, "error in All: %v", err) assert.True(mt, len(got) < 10, "expected len(got) < 10, got: %v", len(got)) for _, doc := range got { gotValue, err := doc.LookupErr("encryptedIndexed") assert.Nil(mt, err, "error in LookupErr: %v", err) assert.Equal(mt, gotValue.StringValue(), valueToEncrypt, "expected %q, got %q", valueToEncrypt, gotValue.StringValue()) } } // Explicit encrypt an indexed value to find with contentionFactor 10. { eo := options.Encrypt().SetAlgorithm("Indexed").SetKeyID(key1ID).SetQueryType(options.QueryTypeEquality).SetContentionFactor(10) findPayload2, err := clientEncryption.Encrypt(context.Background(), rawVal, eo) assert.Nil(mt, err, "error in Encrypt: %v", err) // Find with contentionFactor=10. cursor, err := coll.Find(context.Background(), bson.D{{"encryptedIndexed", findPayload2}}) assert.Nil(mt, err, "error in Find: %v", err) var got []bson.Raw err = cursor.All(context.Background(), &got) assert.Nil(mt, err, "error in All: %v", err) assert.True(mt, len(got) == 10, "expected len(got) == 10, got: %v", len(got)) for _, doc := range got { gotValue, err := doc.LookupErr("encryptedIndexed") assert.Nil(mt, err, "error in LookupErr: %v", err) assert.Equal(mt, gotValue.StringValue(), valueToEncrypt, "expected %q, got %q", valueToEncrypt, gotValue.StringValue()) } } }) mt.Run("case 3: can insert encrypted unindexed", func(mt mtest.T) { encryptedClient, clientEncryption := testSetup() defer clientEncryption.Close(context.Background()) defer encryptedClient.Disconnect(context.Background()) // Explicit encrypt the value "encrypted indexed value" with algorithm: "Indexed". eo := options.Encrypt().SetAlgorithm("Unindexed").SetKeyID(key1ID) valueToEncrypt := "encrypted unindexed value" rawVal := bson.RawValue{Type: bson.TypeString, Value: bsoncore.AppendString(nil, valueToEncrypt)} insertPayload, err := clientEncryption.Encrypt(context.Background(), rawVal, eo) assert.Nil(mt, err, "error in Encrypt: %v", err) // Insert. coll := encryptedClient.Database("db").Collection("explicit_encryption") _, err = coll.InsertOne(context.Background(), bson.D{{"_id", 1}, {"encryptedUnindexed", insertPayload}}) assert.Nil(mt, err, "Error in InsertOne: %v", err) // Find. res := coll.FindOne(context.Background(), bson.D{{"_id", 1}}) assert.Nil(mt, res.Err(), "Error in FindOne: %v", res.Err()) got, err := res.Raw() assert.Nil(mt, err, "error in Raw: %v", err) gotValue, err := got.LookupErr("encryptedUnindexed") assert.Nil(mt, err, "error in LookupErr: %v", err) assert.Equal(mt, gotValue.StringValue(), valueToEncrypt, "expected %q, got %q", valueToEncrypt, gotValue.StringValue()) }) mt.Run("case 4: can roundtrip encrypted indexed", func(mt mtest.T) { encryptedClient, clientEncryption := testSetup() defer clientEncryption.Close(context.Background()) defer encryptedClient.Disconnect(context.Background()) // Explicit encrypt the value "encrypted indexed value" with algorithm: "Indexed". eo := options.Encrypt().SetAlgorithm("Indexed").SetKeyID(key1ID).SetContentionFactor(0) valueToEncrypt := "encrypted indexed value" rawVal := bson.RawValue{Type: bson.TypeString, Value: bsoncore.AppendString(nil, valueToEncrypt)} payload, err := clientEncryption.Encrypt(context.Background(), rawVal, eo) assert.Nil(mt, err, "error in Encrypt: %v", err) gotValue, err := clientEncryption.Decrypt(context.Background(), payload) assert.Nil(mt, err, "error in Decrypt: %v", err) assert.Equal(mt, gotValue.StringValue(), valueToEncrypt, "expected %q, got %q", valueToEncrypt, gotValue.StringValue()) }) mt.Run("case 5: can roundtrip encrypted unindexed", func(mt mtest.T) { encryptedClient, clientEncryption := testSetup() defer clientEncryption.Close(context.Background()) defer encryptedClient.Disconnect(context.Background()) // Explicit encrypt the value "encrypted indexed value" with algorithm: "Indexed". eo := options.Encrypt().SetAlgorithm("Unindexed").SetKeyID(key1ID) valueToEncrypt := "encrypted unindexed value" rawVal := bson.RawValue{Type: bson.TypeString, Value: bsoncore.AppendString(nil, valueToEncrypt)} payload, err := clientEncryption.Encrypt(context.Background(), rawVal, eo) assert.Nil(mt, err, "error in Encrypt: %v", err) gotValue, err := clientEncryption.Decrypt(context.Background(), payload) assert.Nil(mt, err, "error in Decrypt: %v", err) assert.Equal(mt, gotValue.StringValue(), valueToEncrypt, "expected %q, got %q", valueToEncrypt, gotValue.StringValue()) }) }) runOpts = mtest.NewOptions().MinServerVersion("4.2"). Topologies(mtest.ReplicaSet, mtest.LoadBalanced, mtest.ShardedReplicaSet) mt.RunOpts("13. Unique Index on keyAltNames", runOpts, func(mt mtest.T) { const ( dkCollection = "datakeys" idKey = "_id" kvDatabase = "keyvault" defKeyAltName = "def" abcKeyAltName = "abc" ) var cse cseProseTest var initialize = func() primitive.Binary { // Create a ClientEncryption object (referred to as client_encryption) with client set as the keyVaultClient. // Using client, drop the collection keyvault.datakeys. cse = setup(mt, nil, defaultKvClientOptions, options.ClientEncryption(). SetKmsProviders(fullKmsProvidersMap). SetKeyVaultNamespace(kvNamespace)) err := cse.kvClient.Database(kvDatabase).Collection(dkCollection).Drop(context.Background()) assert.Nil(mt, err, "error dropping %q namespace: %v", kvNamespace, err) // Using client, create a unique index on keyAltNames with a partial index filter for only documents where // keyAltNames exists using writeConcern "majority". keyVaultIndex := mongo.IndexModel{ Keys: bson.D{{"keyAltNames", 1}}, Options: options.Index(). SetUnique(true). SetName("keyAltNames_1"). SetPartialFilterExpression(bson.D{ {"keyAltNames", bson.D{ {"$exists", true}, }}, }), } wcMajority := writeconcern.New(writeconcern.WMajority(), writeconcern.WTimeout(1time.Second)) wcMajorityCollectionOpts := options.Collection().SetWriteConcern(wcMajority) wcmColl := cse.kvClient.Database(kvDatabase).Collection(dkCollection, wcMajorityCollectionOpts) _, err = wcmColl.Indexes().CreateOne(context.Background(), keyVaultIndex) assert.Nil(mt, err, "error creating keyAltNames index: %v", err) // Using client_encryption, create a data key with a local KMS provider and the keyAltName "def". opts := options.DataKey().SetKeyAltNames([]string{defKeyAltName}) defKeyID, err := cse.clientEnc.CreateDataKey(context.Background(), "local", opts) assert.Nil(mt, err, "error creating %q data key: %v", defKeyAltName, err) return defKeyID } var validateAddKeyAltName = func(mt mtest.T, cse cseProseTest, res mongo.SingleResult, expected ...string) { assert.Nil(mt, res.Err(), "error adding key alt name: %v", res.Err()) resbytes, err := res.Raw() assert.Nil(mt, err, "error decoding result bytes: %v", err) idsubtype, iddata := bson.RawValue{Type: bsontype.EmbeddedDocument, Value: resbytes}. Document().Lookup("_id").Binary() filter := bsoncore.NewDocumentBuilder().AppendBinary("_id", idsubtype, iddata).Build() ctx := context.Background() updatedData, err := cse.keyVaultColl.FindOne(ctx, filter).Raw() assert.Nil(mt, err, "error decoding result bytes: %v", err) updated := bson.RawValue{Type: bsontype.EmbeddedDocument, Value: updatedData} updatedKeyAltNames, err := updated.Document().Lookup("keyAltNames").Array().Values() assert.Nil(mt, err, "error looking up raw keyAltNames: %v", err) assert.Equal(mt, len(updatedKeyAltNames), len(expected), "expected raw keyAltNames length to be 1") for idx, keyAltName := range updatedKeyAltNames { str := keyAltName.StringValue() assert.Equal(mt, str, expected[idx], "expected keyAltName to be %q, got: %q", expected[idx], str) } } mt.Run("case 1: createKey()", func(mt mtest.T) { initialize() // Use client_encryption to create a new local data key with a keyAltName "abc" and assert the operation // does not fail. opts := options.DataKey().SetKeyAltNames([]string{abcKeyAltName}) _, err := cse.clientEnc.CreateDataKey(context.Background(), "local", opts) assert.Nil(mt, err, "error creating %q data key: %v", abcKeyAltName, err) // Repeat Step 1 and assert the operation fails due to a duplicate key server error (error code 11000). opts = options.DataKey().SetKeyAltNames([]string{abcKeyAltName}) _, err = cse.clientEnc.CreateDataKey(context.Background(), "local", opts) assert.NotNil(mt, err, "duplicate %q key did not propagate expected error", abcKeyAltName) e110000 := "E11000 duplicate key" correctError := strings.Contains(err.Error(), e110000) assert.True(t, correctError, "expected error to contain %q, got: %v", e110000, err) // Use client_encryption to create a new local data key with a keyAltName "def" and assert the operation // fails due to a duplicate key server error (error code 11000). opts = options.DataKey().SetKeyAltNames([]string{defKeyAltName}) _, err = cse.clientEnc.CreateDataKey(context.Background(), "local", opts) assert.NotNil(mt, err, "duplicate %q key did not propagate expected error", defKeyAltName) e110000 = "E11000 duplicate key" correctError = strings.Contains(err.Error(), e110000) assert.True(t, correctError, "expected error to contain %q, got: %v", e110000, err) }) mt.Run("case 2: addKeyAltName()", func(t mtest.T) { defKeyID := initialize() var someNewKeyID primitive.Binary // Use client_encryption to create a new local data key and assert the operation does not fail. var err error someNewKeyID, err = cse.clientEnc.CreateDataKey(context.Background(), "local") assert.Nil(mt, err, "error creating data key: %v", err) // Use client_encryption to add a keyAltName "abc" to the key created in Step 1 and assert the operation // does not fail. res := cse.clientEnc.AddKeyAltName(context.Background(), someNewKeyID, abcKeyAltName) validateAddKeyAltName(mt, cse, res, abcKeyAltName) // Repeat Step 2, assert the operation does not fail, and assert the returned key document contains the // keyAltName "abc" added in Step 2. res = cse.clientEnc.AddKeyAltName(context.Background(), someNewKeyID, abcKeyAltName) validateAddKeyAltName(mt, cse, res, abcKeyAltName) // Use client_encryption to add a keyAltName "def" to the key created in Step 1 and assert the operation // fails due to a duplicate key server error (error code 11000). res = cse.clientEnc.AddKeyAltName(context.Background(), someNewKeyID, defKeyAltName) assert.NotNil(mt, res.Err(), "duplicate %q key did not propagate expected error", defKeyAltName) e110000 := "E11000 duplicate key" correctError := strings.Contains(res.Err().Error(), e110000) assert.True(t, correctError, "expected error to contain %q, got: %v", e110000, res.Err()) // Use client_encryption to add a keyAltName "def" to the existing key, assert the operation does not fail, // and assert the returned key document contains the keyAltName "def" added during Setup. res = cse.clientEnc.AddKeyAltName(context.Background(), defKeyID, defKeyAltName) validateAddKeyAltName(mt, cse, res, defKeyAltName) }) }) mt.RunOpts("16. Rewrap", runOpts, func(mt mtest.T) { mt.Run("Case 1: Rewrap with separate ClientEncryption", func(mt mtest.T) { dataKeyMap := map[string]bson.M{ "aws": { "region": "us-east-1", "key": "arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0", }, "azure": { "keyVaultEndpoint": "key-vault-csfle.vault.azure.net", "keyName": "key-name-csfle", }, "gcp": { "projectId": "devprod-drivers", "location": "global", "keyRing": "key-ring-csfle", "keyName": "key-name-csfle", }, "kmip": {}, } tlsConfig := make(map[string]tls.Config) if tlsCAFileKMIP != "" && tlsClientCertificateKeyFileKMIP != "" { tlsOpts := map[string]interface{}{ "tlsCertificateKeyFile": tlsClientCertificateKeyFileKMIP, "tlsCAFile": tlsCAFileKMIP, } kmipConfig, err := options.BuildTLSConfig(tlsOpts) assert.Nil(mt, err, "BuildTLSConfig error: %v", err) tlsConfig["kmip"] = kmipConfig } kmsProviders := []string{"local", "aws", "gcp", "azure", "kmip"} for _, srcProvider := range kmsProviders { for _, dstProvider := range kmsProviders { mt.Run(fmt.Sprintf("%s to %s", srcProvider, dstProvider), func(mt mtest.T) { var err error // Drop the collection ``keyvault.datakeys``. { err = mt.Client.Database("keyvault").Collection("datakeys").Drop(context.Background()) assert.Nil(mt, err, "error on Drop: %v", err) } // Create a ``ClientEncryption`` object named ``clientEncryption1``. var clientEncryption1 mongo.ClientEncryption { var keyVaultClient mongo.Client { co := options.Client().ApplyURI(mtest.ClusterURI()) keyVaultClient, err = mongo.Connect(context.Background(), co) defer keyVaultClient.Disconnect(context.Background()) integtest.AddTestServerAPIVersion(co) assert.Nil(mt, err, "error on Connect: %v", err) } ceOpts := options.ClientEncryption(). SetKeyVaultNamespace("keyvault.datakeys"). SetKmsProviders(fullKmsProvidersMap). SetTLSConfig(tlsConfig) clientEncryption1, err = mongo.NewClientEncryption(keyVaultClient, ceOpts) assert.Nil(mt, err, "error in NewClientEncryption: %v", err) defer clientEncryption1.Close(context.Background()) } // Call ``clientEncryption1.createDataKey``. var keyID primitive.Binary { dkOpts := options.DataKey() if val, ok := dataKeyMap[srcProvider]; ok { dkOpts.SetMasterKey(val) } keyID, err = clientEncryption1.CreateDataKey(context.Background(), srcProvider, dkOpts) assert.Nil(mt, err, "error in CreateDataKey: %v", err) } // Call ``clientEncryption1.encrypt`` with the value "test". var ciphertext primitive.Binary { t, value, err := bson.MarshalValue("test") assert.Nil(mt, err, "error in MarshalValue: %v", err) plaintext := bson.RawValue{Type: t, Value: value} eOpts := options.Encrypt().SetKeyID(keyID).SetAlgorithm("AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic") ciphertext, err = clientEncryption1.Encrypt(context.Background(), plaintext, eOpts) assert.Nil(mt, err, "error in Encrypt: %v", err) } // Create a ``ClientEncryption`` object named ``clientEncryption2``. var clientEncryption2 mongo.ClientEncryption { var keyVaultClient mongo.Client { co := options.Client().ApplyURI(mtest.ClusterURI()) keyVaultClient, err = mongo.Connect(context.Background(), co) defer keyVaultClient.Disconnect(context.Background()) integtest.AddTestServerAPIVersion(co) assert.Nil(mt, err, "error on Connect: %v", err) } ceOpts := options.ClientEncryption(). SetKeyVaultNamespace("keyvault.datakeys"). SetKmsProviders(fullKmsProvidersMap). SetTLSConfig(tlsConfig) clientEncryption2, err = mongo.NewClientEncryption(keyVaultClient, ceOpts) assert.Nil(mt, err, "error in NewClientEncryption: %v", err) defer clientEncryption2.Close(context.Background()) } // Call ``clientEncryption2.rewrapManyDataKey`` with an empty ``filter``. { rwOpts := options.RewrapManyDataKey().SetProvider(dstProvider) if val, ok := dataKeyMap[dstProvider]; ok { rwOpts.SetMasterKey(val) } res, err := clientEncryption2.RewrapManyDataKey(context.Background(), bson.D{}, rwOpts) assert.Nil(mt, err, "error in RewrapManyDataKey: %v", err) assert.Equal(mt, res.BulkWriteResult.ModifiedCount, int64(1), "expected ModifiedCount of 1, got %v", res.BulkWriteResult.ModifiedCount) } // Call ``clientEncryption1.decrypt`` with the ``ciphertext``. { plaintext, err := clientEncryption1.Decrypt(context.Background(), ciphertext) assert.Nil(mt, err, "error in Decrypt: %v", err) assert.Equal(mt, plaintext.StringValue(), "test", "expected plaintext 'test', got %q", plaintext.StringValue()) } // Call ``clientEncryption2.decrypt`` with the ``ciphertext``. { plaintext, err := clientEncryption2.Decrypt(context.Background(), ciphertext) assert.Nil(mt, err, "error in Decrypt: %v", err) assert.Equal(mt, plaintext.StringValue(), "test", "expected plaintext 'test', got %q", plaintext.StringValue()) } }) } } }) mt.Run("Case 2: RewrapManyDataKeyOpts.provider is not optional", func(mt mtest.T) { var err error var clientEncryption mongo.ClientEncryption { var keyVaultClient mongo.Client { co := options.Client().ApplyURI(mtest.ClusterURI()) keyVaultClient, err = mongo.Connect(context.Background(), co) defer keyVaultClient.Disconnect(context.Background()) integtest.AddTestServerAPIVersion(co) assert.Nil(mt, err, "error on Connect: %v", err) } ceOpts := options.ClientEncryption(). SetKeyVaultNamespace("keyvault.datakeys"). SetKmsProviders(fullKmsProvidersMap) clientEncryption, err = mongo.NewClientEncryption(keyVaultClient, ceOpts) assert.Nil(mt, err, "error in NewClientEncryption: %v", err) defer clientEncryption.Close(context.Background()) } _, err = clientEncryption.RewrapManyDataKey(context.Background(), bson.D{}, options.RewrapManyDataKey().SetMasterKey(bson.D{})) assert.ErrorContains(mt, err, "expected 'Provider' to be set to identify type of 'MasterKey'") }) }) mt.RunOpts("18. Azure IMDS Credentials", noClientOpts, func(mt mtest.T) { buf := make([]byte, 0, 256) kmsProvidersMap := map[string]map[string]interface{}{ "azure": {}, } p, err := bson.MarshalAppend(buf[:0], kmsProvidersMap) assert.Nil(mt, err, "error in MarshalAppendWithRegistry: %v", err) getClient := func(header http.Header) http.Client { lt := &localTransport{ header: header, rt: http.DefaultTransport, } return &http.Client{ Timeout: 30 time.Second, Transport: lt, } } mt.Run("Case 1: Success", func(mt mtest.T) { opts := &mongocryptopts.MongoCryptOptions{ KmsProviders: p, HTTPClient: getClient(nil), } crypt, err := mongocrypt.NewMongoCrypt(opts) assert.Nil(mt, err, "error in NewMongoCrypt: %v", err) doc, err := crypt.GetKmsProviders(context.Background()) assert.Nil(mt, err, "error in GetKmsProviders: %v", err) val, err := doc.LookupErr("azure") assert.Nil(mt, err, "error in LookupErr: %v", err) assert.Equal(mt, `{"accessToken": "magic-cookie"}`, val.String(), "expected accessToken, got %s", val.String()) }) mt.Run("Case 2: Empty JSON", func(mt mtest.T) { header := make(http.Header) header.Set("X-MongoDB-HTTP-TestParams", "case=empty-json") opts := &mongocryptopts.MongoCryptOptions{ KmsProviders: p, HTTPClient: getClient(header), } crypt, err := mongocrypt.NewMongoCrypt(opts) assert.Nil(mt, err, "error in NewMongoCrypt: %v", err) _, err = crypt.GetKmsProviders(context.Background()) assert.ErrorContains(mt, err, "got unexpected empty accessToken") }) mt.Run("Case 3: Bad JSON", func(mt mtest.T) { header := make(http.Header) header.Set("X-MongoDB-HTTP-TestParams", "case=bad-json") opts := &mongocryptopts.MongoCryptOptions{ KmsProviders: p, HTTPClient: getClient(header), } crypt, err := mongocrypt.NewMongoCrypt(opts) assert.Nil(mt, err, "error in NewMongoCrypt: %v", err) _, err = crypt.GetKmsProviders(context.Background()) assert.ErrorContains(mt, err, "error reading body JSON") }) mt.Run("Case 4: HTTP 404", func(mt mtest.T) { header := make(http.Header) header.Set("X-MongoDB-HTTP-TestParams", "case=404") opts := &mongocryptopts.MongoCryptOptions{ KmsProviders: p, HTTPClient: getClient(header), } crypt, err := mongocrypt.NewMongoCrypt(opts) assert.Nil(mt, err, "error in NewMongoCrypt: %v", err) _, err = crypt.GetKmsProviders(context.Background()) assert.ErrorContains(mt, err, "got StatusCode: 404") }) mt.Run("Case 5: HTTP 500", func(mt mtest.T) { header := make(http.Header) header.Set("X-MongoDB-HTTP-TestParams", "case=500") opts := &mongocryptopts.MongoCryptOptions{ KmsProviders: p, HTTPClient: getClient(header), } crypt, err := mongocrypt.NewMongoCrypt(opts) assert.Nil(mt, err, "error in NewMongoCrypt: %v", err) _, err = crypt.GetKmsProviders(context.Background()) assert.ErrorContains(mt, err, "got StatusCode: 500") }) mt.Run("Case 6: Slow Response", func(mt mtest.T) { header := make(http.Header) header.Set("X-MongoDB-HTTP-TestParams", "case=slow") opts := &mongocryptopts.MongoCryptOptions{ KmsProviders: p, HTTPClient: getClient(header), } crypt, err := mongocrypt.NewMongoCrypt(opts) assert.Nil(mt, err, "error in NewMongoCrypt: %v", err) _, err = crypt.GetKmsProviders(context.Background()) possibleErrors := []string{ "error reading response body: context deadline exceeded", // <= 1.19 + RHEL & macOS "Client.Timeout or context cancellation while reading body", // > 1.20 on all OS } assert.True(t, containsSubstring(possibleErrors, err.Error()), "expected possibleErrors=%v to contain %v, but it didn't", possibleErrors, err.Error()) }) }) mt.RunOpts("20. Bypass creating mongocryptd client when shared library is loaded", noClientOpts, func(mt mtest.T) { cryptSharedLibPath := os.Getenv("CRYPT_SHARED_LIB_PATH") if cryptSharedLibPath == "" { mt.Skip("CRYPT_SHARED_LIB_PATH not set, skipping") return } kmsProviders := map[string]map[string]interface{}{ "local": { "key": localMasterKey, }, } // Listen for connections in a separate goroutine. listener := listenForConnections(t, func(c net.Conn) { mt.Fatalf("Unexpected connection created to mock mongocryptd goroutine") c.Close() }) defer listener.Close() uri := "mongodb://" + listener.Addr().String() mongocryptdSpawnArgs := map[string]interface{}{ "mongocryptdURI": uri, "cryptSharedLibPath": cryptSharedLibPath, } aeo := options.AutoEncryption().SetKmsProviders(kmsProviders). SetExtraOptions(mongocryptdSpawnArgs) cliOpts := options.Client().ApplyURI(mtest.ClusterURI()).SetAutoEncryptionOptions(aeo) integtest.AddTestServerAPIVersion(cliOpts) encClient, err := mongo.Connect(context.Background(), cliOpts) assert.Nil(mt, err, "Connect error: %v", err) defer func() { err = encClient.Disconnect(context.Background()) assert.Nil(mt, err, "encrypted client Disconnect error: %v", err) }() // Run an Insert through the encrypted client to make sure mongocryptd is started ('insert' uses the // mongocryptd and will wait for it to be active). _, err = encClient.Database("db").Collection("coll").InsertOne(context.Background(), bson.D{{"unencrypted", "test"}}) assert.Nil(mt, err, "InsertOne error: %v", err) }) // qeRunOpts are requirements for Queryable Encryption. qeRunOpts := mtest.NewOptions().MinServerVersion("7.0").Topologies(mtest.ReplicaSet, mtest.Sharded, mtest.LoadBalanced, mtest.ShardedReplicaSet) // Only test MongoDB Server 7.0+. MongoDB Server 7.0 introduced a backwards breaking change to the Queryable Encryption (QE) protocol: QEv2. // libmongocrypt is configured to use the QEv2 protocol. mt.RunOpts("21. automatic data encryption keys", qeRunOpts, func(mt mtest.T) { setup := func() (mongo.Client, mongo.ClientEncryption, error) { opts := options.Client().ApplyURI(mtest.ClusterURI()) client, err := mongo.Connect(context.Background(), opts) if err != nil { return nil, nil, err } client.Database("keyvault").Collection("datakeys").Drop(context.Background()) client.Database("db").Drop(context.Background()) ceo := options.ClientEncryption(). SetKmsProviders(fullKmsProvidersMap). SetKeyVaultNamespace(kvNamespace) clientEnc, err := mongo.NewClientEncryption(client, ceo) if err != nil { return nil, nil, err } return client, clientEnc, nil } type KMSProviderTestcase struct { kmsProvider string masterKey bson.D } testcases := []KMSProviderTestcase{ { kmsProvider: "local", masterKey: nil, }, { kmsProvider: "aws", masterKey: &bson.D{ {"region", "us-east-1"}, {"key", "arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0"}, }, }, } for _, tc := range testcases { mt.Run(tc.kmsProvider, func(mt mtest.T) { mt.Run("case 1: simple creation and validation", func(mt mtest.T) { client, clientEnc, err := setup() assert.Nil(mt, err, "setup error: %v", err) defer func() { err := clientEnc.Close(context.Background()) assert.Nil(mt, err, "error in Close") }() var encryptedFields bson.Raw err = bson.UnmarshalExtJSON([]byte(`{ "fields": [{ "path": "ssn", "bsonType": "string", "keyId": null }] }`), true / canonical /, &encryptedFields) assert.Nil(mt, err, "Unmarshal error: %v", err) coll, _, err := clientEnc.CreateEncryptedCollection( context.Background(), client.Database("db"), "testing1", options.CreateCollection().SetEncryptedFields(encryptedFields), "local", nil, ) assert.Nil(mt, err, "CreateCollection error: %v", err) _, err = coll.InsertOne(context.Background(), bson.D{{"ssn", "123-45-6789"}}) assert.ErrorContains(mt, err, "Document failed validation") }) mt.Run("case 2: missing encryptedFields", func(mt mtest.T) { client, clientEnc, err := setup() assert.Nil(mt, err, "setup error: %v", err) defer func() { err := clientEnc.Close(context.Background()) assert.Nil(mt, err, "error in Close") }() coll, _, err := clientEnc.CreateEncryptedCollection( context.Background(), client.Database("db"), "testing1", options.CreateCollection(), "local", nil, ) assert.Nil(mt, coll, "expect nil collection") assert.EqualError(mt, err, "no EncryptedFields defined for the collection") }) mt.Run("case 3: invalid keyId", func(mt mtest.T) { client, clientEnc, err := setup() assert.Nil(mt, err, "setup error: %v", err) defer func() { err := clientEnc.Close(context.Background()) assert.Nil(mt, err, "error in Close") }() var encryptedFields bson.Raw err = bson.UnmarshalExtJSON([]byte(`{ "fields": [{ "path": "ssn", "bsonType": "string", "keyId": false }] }`), true / canonical /, &encryptedFields) assert.Nil(mt, err, "Unmarshal error: %v", err) _, _, err = clientEnc.CreateEncryptedCollection( context.Background(), client.Database("db"), "testing1", options.CreateCollection().SetEncryptedFields(encryptedFields), "local", nil, ) assert.ErrorContains(mt, err, "BSON field 'create.encryptedFields.fields.keyId' is the wrong type 'bool', expected type 'binData'") }) mt.Run("case 4: insert encrypted value", func(mt mtest.T) { client, clientEnc, err := setup() assert.Nil(mt, err, "setup error: %v", err) defer func() { err := clientEnc.Close(context.Background()) assert.Nil(mt, err, "error in Close") }() var encryptedFields bson.Raw err = bson.UnmarshalExtJSON([]byte(`{ "fields": [{ "path": "ssn", "bsonType": "string", "keyId": null }] }`), true /* canonical /, &encryptedFields) assert.Nil(mt, err, "Unmarshal error: %v", err) coll, ef, err := clientEnc.CreateEncryptedCollection( context.Background(), client.Database("db"), "testing1", options.CreateCollection().SetEncryptedFields(encryptedFields), "local", nil, ) assert.Nil(mt, err, "CreateCollection error: %v", err) keyid := ef["fields"].(bson.A)[0].(bson.M)["keyId"].(primitive.Binary) rawValueType, rawValueData, err := bson.MarshalValue("123-45-6789") assert.Nil(mt, err, "MarshalValue error: %v", err) rawValue := bson.RawValue{Type: rawValueType, Value: rawValueData} encryptionOpts := options.Encrypt(). SetAlgorithm("Unindexed"). SetKeyID(keyid) encryptedField, err := clientEnc.Encrypt( context.Background(), rawValue, encryptionOpts) assert.Nil(mt, err, "Encrypt error: %v", err) _, err = coll.InsertOne(context.Background(), bson.D{{"ssn", encryptedField}}) assert.Nil(mt, err, "InsertOne error: %v", err) }) }) } }) // Only test MongoDB Server 7.0+. MongoDB Server 7.0 introduced a backwards breaking change to the Queryable Encryption (QE) protocol: QEv2. // libmongocrypt is configured to use the QEv2 protocol. mt.RunOpts("22. range explicit encryption", qeRunOpts, func(mt mtest.T) { type testcase struct { typeStr string field string typeBson bsontype.Type rangeOpts options.RangeOptions zero bson.RawValue six bson.RawValue thirty bson.RawValue twoHundred bson.RawValue twoHundredOne bson.RawValue } precision := int32(2) d128_0, err := primitive.ParseDecimal128("0") assert.Nil(mt, err) d128_6, err := primitive.ParseDecimal128("6") assert.Nil(mt, err) d128_30, err := primitive.ParseDecimal128("30") assert.Nil(mt, err) d128_200, err := primitive.ParseDecimal128("200") assert.Nil(mt, err) d128_201, err := primitive.ParseDecimal128("201") assert.Nil(mt, err) tests := []testcase{ { typeStr: "DecimalNoPrecision", field: "encryptedDecimalNoPrecision", typeBson: bson.TypeDecimal128, rangeOpts: options.RangeOptions{ Sparsity: 1, }, zero: bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_0)}, six: bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_6)}, thirty: bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_30)}, twoHundred: bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_200)}, twoHundredOne: bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_201)}, }, { typeStr: "DecimalPrecision", field: "encryptedDecimalPrecision", typeBson: bson.TypeDecimal128, rangeOpts: options.RangeOptions{ Min: &bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_0)}, Max: &bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_200)}, Sparsity: 1, Precision: &precision, }, zero: bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_0)}, six: bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_6)}, thirty: bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_30)}, twoHundred: bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_200)}, twoHundredOne: bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_201)}, }, { typeStr: "DoubleNoPrecision", field: "encryptedDoubleNoPrecision", typeBson: bson.TypeDouble, rangeOpts: options.RangeOptions{ Sparsity: 1, }, zero: bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 0)}, six: bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 6)}, thirty: bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 30)}, twoHundred: bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 200)}, twoHundredOne: bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 201)}, }, { typeStr: "DoublePrecision", field: "encryptedDoublePrecision", typeBson: bson.TypeDouble, rangeOpts: options.RangeOptions{ Min: &bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 0)}, Max: &bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 200)}, Sparsity: 1, Precision: &precision, }, zero: bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 0)}, six: bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 6)}, thirty: bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 30)}, twoHundred: bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 200)}, twoHundredOne: bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 201)}, }, { typeStr: "Date", field: "encryptedDate", typeBson: bson.TypeDateTime, rangeOpts: options.RangeOptions{ Min: &bson.RawValue{Type: bson.TypeDateTime, Value: bsoncore.AppendDateTime(nil, 0)}, Max: &bson.RawValue{Type: bson.TypeDateTime, Value: bsoncore.AppendDateTime(nil, 200)}, Sparsity: 1, }, zero: bson.RawValue{Type: bson.TypeDateTime, Value: bsoncore.AppendDateTime(nil, 0)}, six: bson.RawValue{Type: bson.TypeDateTime, Value: bsoncore.AppendDateTime(nil, 6)}, thirty: bson.RawValue{Type: bson.TypeDateTime, Value: bsoncore.AppendDateTime(nil, 30)}, twoHundred: bson.RawValue{Type: bson.TypeDateTime, Value: bsoncore.AppendDateTime(nil, 200)}, twoHundredOne: bson.RawValue{Type: bson.TypeDateTime, Value: bsoncore.AppendDateTime(nil, 201)}, }, { typeStr: "Int", field: "encryptedInt", typeBson: bson.TypeInt32, rangeOpts: options.RangeOptions{ Min: &bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 0)}, Max: &bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 200)}, Sparsity: 1, }, zero: bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 0)}, six: bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 6)}, thirty: bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 30)}, twoHundred: bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 200)}, twoHundredOne: bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 201)}, }, { typeStr: "Long", field: "encryptedLong", typeBson: bson.TypeInt64, rangeOpts: options.RangeOptions{ Min: &bson.RawValue{Type: bson.TypeInt64, Value: bsoncore.AppendInt64(nil, 0)}, Max: &bson.RawValue{Type: bson.TypeInt64, Value: bsoncore.AppendInt64(nil, 200)}, Sparsity: 1, }, zero: bson.RawValue{Type: bson.TypeInt64, Value: bsoncore.AppendInt64(nil, 0)}, six: bson.RawValue{Type: bson.TypeInt64, Value: bsoncore.AppendInt64(nil, 6)}, thirty: bson.RawValue{Type: bson.TypeInt64, Value: bsoncore.AppendInt64(nil, 30)}, twoHundred: bson.RawValue{Type: bson.TypeInt64, Value: bsoncore.AppendInt64(nil, 200)}, twoHundredOne: bson.RawValue{Type: bson.TypeInt64, Value: bsoncore.AppendInt64(nil, 201)}, }, } for _, test := range tests { mt.Run(test.typeStr, func(mt mtest.T) { if test.typeStr == "DecimalNoPrecision" && mtest.ClusterTopologyKind() != mtest.ReplicaSet { mt.Skipf("Skipping DecimalNoPrecision tests on a non ReplicaSet topology. DecimalNoPrecision queries are expected to take a long time and may exceed the default mongos timeout") } // Test Setup ... begin encryptedFields := readJSONFile(mt, fmt.Sprintf("range-encryptedFields-%v.json", test.typeStr)) key1Document := readJSONFile(mt, "key1-document.json") var key1ID primitive.Binary { subtype, data := key1Document.Lookup("_id").Binary() key1ID = primitive.Binary{Subtype: subtype, Data: data} } testSetup := func() (mongo.Client, mongo.ClientEncryption) { mtest.DropEncryptedCollection(mt, mt.Client.Database("db").Collection("explicit_encryption"), encryptedFields) cco := options.CreateCollection().SetEncryptedFields(encryptedFields) err := mt.Client.Database("db").CreateCollection(context.Background(), "explicit_encryption", cco) assert.Nil(mt, err, "error on CreateCollection: %v", err) err = mt.Client.Database("keyvault").Collection("datakeys").Drop(context.Background()) assert.Nil(mt, err, "error on Drop: %v", err) keyVaultClient, err := mongo.Connect(context.Background(), options.Client().ApplyURI(mtest.ClusterURI())) assert.Nil(mt, err, "error on Connect: %v", err) datakeysColl := keyVaultClient.Database("keyvault").Collection("datakeys", options.Collection().SetWriteConcern(mtest.MajorityWc)) _, err = datakeysColl.InsertOne(context.Background(), key1Document) assert.Nil(mt, err, "error on InsertOne: %v", err) // Create a ClientEncryption. ceo := options.ClientEncryption(). SetKeyVaultNamespace("keyvault.datakeys"). SetKmsProviders(fullKmsProvidersMap) clientEncryption, err := mongo.NewClientEncryption(keyVaultClient, ceo) assert.Nil(mt, err, "error on NewClientEncryption: %v", err) // Create a MongoClient with AutoEncryptionOpts and bypassQueryAnalysis=true. aeo := options.AutoEncryption(). SetKeyVaultNamespace("keyvault.datakeys"). SetKmsProviders(fullKmsProvidersMap). SetBypassQueryAnalysis(true) co := options.Client().SetAutoEncryptionOptions(aeo).ApplyURI(mtest.ClusterURI()) encryptedClient, err := mongo.Connect(context.Background(), co) assert.Nil(mt, err, "error on Connect: %v", err) // Insert 0, 6, 30, and 200. coll := encryptedClient.Database("db").Collection("explicit_encryption") eo := options.Encrypt(). SetAlgorithm("RangePreview"). SetKeyID(key1ID). SetContentionFactor(0). SetRangeOptions(test.rangeOpts) // Insert 0. insertPayloadZero, err := clientEncryption.Encrypt(context.Background(), test.zero, eo) assert.Nil(mt, err, "error in Encrypt: %v", err) _, err = coll.InsertOne(context.Background(), bson.D{{"_id", 0}, {test.field, insertPayloadZero}}) assert.Nil(mt, err, "error in InsertOne: %v", err) // Insert 6. insertPayloadSix, err := clientEncryption.Encrypt(context.Background(), test.six, eo) assert.Nil(mt, err, "error in Encrypt: %v", err) _, err = coll.InsertOne(context.Background(), bson.D{{"_id", 1}, {test.field, insertPayloadSix}}) assert.Nil(mt, err, "error in InsertOne: %v", err) // Insert 30. insertPayloadThirty, err := clientEncryption.Encrypt(context.Background(), test.thirty, eo) assert.Nil(mt, err, "error in Encrypt: %v", err) _, err = coll.InsertOne(context.Background(), bson.D{{"_id", 2}, {test.field, insertPayloadThirty}}) assert.Nil(mt, err, "error in InsertOne: %v", err) // Insert 200. insertPayloadTwoHundred, err := clientEncryption.Encrypt(context.Background(), test.twoHundred, eo) assert.Nil(mt, err, "error in Encrypt: %v", err) _, err = coll.InsertOne(context.Background(), bson.D{{"_id", 3}, {test.field, insertPayloadTwoHundred}}) assert.Nil(mt, err, "error in InsertOne: %v", err) return encryptedClient, clientEncryption } // Test Setup ... end // checkCursorResults checks documents returned by a cursor. // Expects document i to have field `field` with value `values[i]`. // Expects exactly len(values) documents to be returned. checkCursorResults := func(cursor mongo.Cursor, field string, values ...bson.RawValue) { for i, v := range values { assert.True(mt, cursor.Next(context.Background()), "expected Next true, got false. Expected document %v with value: %v", i, v) got, err := cursor.Current.LookupErr(test.field) assert.Nil(mt, err, "%v not found in document %v: %v", test.field, i, cursor.Current) assert.Equal(mt, v, got, "expected %v, got %v in document %v", v, got, i) } assert.False(mt, cursor.Next(context.Background()), "expected Next false, got true with document: %v", cursor.Current) } mt.Run("Case 1: can decrypt a payload", func(mt mtest.T) { encryptedClient, clientEncryption := testSetup() defer clientEncryption.Close(context.Background()) defer encryptedClient.Disconnect(context.Background()) eo := options.Encrypt(). SetAlgorithm("RangePreview"). SetKeyID(key1ID). SetContentionFactor(0). SetRangeOptions(test.rangeOpts) insertPayloadSix, err := clientEncryption.Encrypt(context.Background(), test.six, eo) assert.Nil(mt, err, "error in Encrypt: %v", err) got, err := clientEncryption.Decrypt(context.Background(), insertPayloadSix) assert.Nil(mt, err, "error in Decrypt: %v", err) assert.Equal(mt, test.six, got, "expected %v, got %v", test.six, got) }) mt.Run("Case 2: can find encrypted range and return the maximum", func(mt mtest.T) { encryptedClient, clientEncryption := testSetup() defer clientEncryption.Close(context.Background()) defer encryptedClient.Disconnect(context.Background()) eo := options.Encrypt(). SetAlgorithm("RangePreview"). SetKeyID(key1ID). SetContentionFactor(0). SetQueryType("rangePreview"). SetRangeOptions(test.rangeOpts) expr := bson.M{ "$and": bson.A{ bson.M{ test.field: bson.M{ "$gte": test.six, }, }, bson.M{ test.field: bson.M{ "$lte": test.twoHundred, }, }, }, } // Encrypt. var encryptedExpr bson.Raw { err := clientEncryption.EncryptExpression(context.Background(), expr, &encryptedExpr, eo) assert.Nil(mt, err, "error in EncryptExpression: %v", err) } coll := encryptedClient.Database("db").Collection("explicit_encryption") opts := options.Find().SetSort(bson.D{{"_id", 1}}) cursor, err := coll.Find(context.Background(), encryptedExpr, opts) assert.Nil(mt, err, "error in coll.Find: %v", err) defer cursor.Close(context.Background()) checkCursorResults(cursor, test.field, test.six, test.thirty, test.twoHundred) }) mt.Run("Case 3: can find encrypted range and return the minimum", func(mt mtest.T) { encryptedClient, clientEncryption := testSetup() defer clientEncryption.Close(context.Background()) defer encryptedClient.Disconnect(context.Background()) eo := options.Encrypt(). SetAlgorithm("RangePreview"). SetKeyID(key1ID). SetContentionFactor(0). SetQueryType("rangePreview"). SetRangeOptions(test.rangeOpts) expr := bson.M{ "$and": bson.A{ bson.M{ test.field: bson.M{ "$gte": test.zero, }, }, bson.M{ test.field: bson.M{ "$lte": test.six, }, }, }, } // Encrypt. var encryptedExpr bson.Raw { err := clientEncryption.EncryptExpression(context.Background(), expr, &encryptedExpr, eo) assert.Nil(mt, err, "error in EncryptExpression: %v", err) } coll := encryptedClient.Database("db").Collection("explicit_encryption") opts := options.Find().SetSort(bson.D{{"_id", 1}}) cursor, err := coll.Find(context.Background(), encryptedExpr, opts) assert.Nil(mt, err, "error in coll.Find: %v", err) defer cursor.Close(context.Background()) checkCursorResults(cursor, test.field, test.zero, test.six) }) mt.Run("Case 4: can find encrypted range with an open range query", func(mt mtest.T) { encryptedClient, clientEncryption := testSetup() defer clientEncryption.Close(context.Background()) defer encryptedClient.Disconnect(context.Background()) eo := options.Encrypt(). SetAlgorithm("RangePreview"). SetKeyID(key1ID). SetContentionFactor(0). SetQueryType("rangePreview"). SetRangeOptions(test.rangeOpts) expr := bson.M{ "$and": bson.A{ bson.M{ test.field: bson.M{ "$gt": test.thirty, }, }, }, } // Encrypt. var encryptedExpr bson.Raw { err := clientEncryption.EncryptExpression(context.Background(), expr, &encryptedExpr, eo) assert.Nil(mt, err, "error in EncryptExpression: %v", err) } coll := encryptedClient.Database("db").Collection("explicit_encryption") opts := options.Find().SetSort(bson.D{{"_id", 1}}) cursor, err := coll.Find(context.Background(), encryptedExpr, opts) assert.Nil(mt, err, "error in coll.Find: %v", err) defer cursor.Close(context.Background()) checkCursorResults(cursor, test.field, test.twoHundred) }) mt.Run("Case 5: can run an aggregation expression inside $expr", func(mt mtest.T) { encryptedClient, clientEncryption := testSetup() defer clientEncryption.Close(context.Background()) defer encryptedClient.Disconnect(context.Background()) eo := options.Encrypt(). SetAlgorithm("RangePreview"). SetKeyID(key1ID). SetContentionFactor(0). SetQueryType("rangePreview"). SetRangeOptions(test.rangeOpts) expr := bson.M{ "$and": bson.A{ bson.M{ "$lt": bson.A{ fmt.Sprintf("$%v", test.field), test.thirty, }, }, }, } // Encrypt. var encryptedExpr bson.Raw { err := clientEncryption.EncryptExpression(context.Background(), expr, &encryptedExpr, eo) assert.Nil(mt, err, "error in EncryptExpression: %v", err) } coll := encryptedClient.Database("db").Collection("explicit_encryption") opts := options.Find().SetSort(bson.D{{"_id", 1}}) cursor, err := coll.Find(context.Background(), bson.M{"$expr": encryptedExpr}, opts) assert.Nil(mt, err, "error in coll.Find: %v", err) defer cursor.Close(context.Background()) checkCursorResults(cursor, test.field, test.zero, test.six) }) if test.field != "encryptedDoubleNoPrecision" && test.field != "encryptedDecimalNoPrecision" { mt.Run("Case 6: encrypting a document greater than the maximum errors", func(mt mtest.T) { encryptedClient, clientEncryption := testSetup() defer clientEncryption.Close(context.Background()) defer encryptedClient.Disconnect(context.Background()) eo := options.Encrypt(). SetAlgorithm("RangePreview"). SetKeyID(key1ID). SetContentionFactor(0). SetRangeOptions(test.rangeOpts) _, err := clientEncryption.Encrypt(context.Background(), test.twoHundredOne, eo) assert.NotNil(mt, err, "expected error, but got none") }) mt.Run("Case 7: encrypting a document of a different type errors", func(mt mtest.T) { encryptedClient, clientEncryption := testSetup() defer clientEncryption.Close(context.Background()) defer encryptedClient.Disconnect(context.Background()) eo := options.Encrypt(). SetAlgorithm("RangePreview"). SetKeyID(key1ID). SetContentionFactor(0). SetRangeOptions(test.rangeOpts) var val bson.RawValue if test.field == "encryptedInt" { val = bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 6)} } else { val = bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 6)} } _, err := clientEncryption.Encrypt(context.Background(), val, eo) assert.NotNil(mt, err, "expected error, but got none") }) } if test.field != "encryptedDoubleNoPrecision" && test.field != "encryptedDoublePrecision" && test.field != "encryptedDecimalNoPrecision" && test.field != "encryptedDecimalPrecision" { mt.Run("Case 8: setting precision errors if the type is not a double", func(mt mtest.T) { encryptedClient, clientEncryption := testSetup() defer clientEncryption.Close(context.Background()) defer encryptedClient.Disconnect(context.Background()) // Copy rangeOpts and set precision. ro := test.rangeOpts ro.SetPrecision(2) eo := options.Encrypt(). SetAlgorithm("RangePreview"). SetKeyID(key1ID). SetContentionFactor(0). SetRangeOptions(ro) _, err := clientEncryption.Encrypt(context.Background(), test.six, eo) assert.NotNil(mt, err, "expected error, but got none") }) } }) } }) } func getWatcher(mt mtest.T, streamType mongo.StreamType, cpt cseProseTest) watcher { mt.Helper() switch streamType { case mongo.ClientStream: return cpt.cseClient case mongo.DatabaseStream: return cpt.cseColl.Database() case mongo.CollectionStream: return cpt.cseColl default: mt.Fatalf("unknown stream type %v", streamType) } return nil } type cseProseTest struct { coll mongo.Collection // collection db.coll kvClient mongo.Client keyVaultColl mongo.Collection cseClient mongo.Client // encrypted client cseColl mongo.Collection // db.coll with encrypted client clientEnc mongo.ClientEncryption cseStarted []event.CommandStartedEvent } func setup(mt mtest.T, aeo options.AutoEncryptionOptions, kvClientOpts options.ClientOptions, ceo options.ClientEncryptionOptions) cseProseTest { mt.Helper() var cpt cseProseTest var err error cpt.coll = mt.CreateCollection(mtest.Collection{ Name: "coll", DB: "db", Opts: options.Collection().SetWriteConcern(mtest.MajorityWc), }, false) cpt.keyVaultColl = mt.CreateCollection(mtest.Collection{ Name: "datakeys", DB: "keyvault", Opts: options.Collection().SetWriteConcern(mtest.MajorityWc), }, false) if aeo != nil { cseMonitor := &event.CommandMonitor{ Started: func(_ context.Context, evt event.CommandStartedEvent) { cpt.cseStarted = append(cpt.cseStarted, evt) }, } opts := options.Client().ApplyURI(mtest.ClusterURI()).SetWriteConcern(mtest.MajorityWc). SetReadPreference(mtest.PrimaryRp).SetAutoEncryptionOptions(aeo).SetMonitor(cseMonitor) integtest.AddTestServerAPIVersion(opts) cpt.cseClient, err = mongo.Connect(context.Background(), opts) assert.Nil(mt, err, "Connect error for encrypted client: %v", err) cpt.cseColl = cpt.cseClient.Database("db").Collection("coll") } if ceo != nil { cpt.kvClient, err = mongo.Connect(context.Background(), kvClientOpts) assert.Nil(mt, err, "Connect error for ClientEncryption key vault client: %v", err) cpt.clientEnc, err = mongo.NewClientEncryption(cpt.kvClient, ceo) assert.Nil(mt, err, "NewClientEncryption error: %v", err) } return &cpt } func (cpt cseProseTest) teardown(mt mtest.T) { mt.Helper() if cpt.cseClient != nil { _ = cpt.cseClient.Disconnect(context.Background()) } if cpt.clientEnc != nil { _ = cpt.clientEnc.Close(context.Background()) } } func readJSONFile(mt mtest.T, file string) bson.Raw { mt.Helper() content, err := ioutil.ReadFile(filepath.Join(clientEncryptionProseDir, file)) assert.Nil(mt, err, "ReadFile error for %v: %v", file, err) var doc bson.Raw err = bson.UnmarshalExtJSON(content, true, &doc) assert.Nil(mt, err, "UnmarshalExtJSON error for file %v: %v", file, err) return doc } func decodeJSONFile(mt mtest.T, file string, val interface{}) bson.Raw { mt.Helper() content, err := ioutil.ReadFile(filepath.Join(clientEncryptionProseDir, file)) assert.Nil(mt, err, "ReadFile error for %v: %v", file, err) var doc bson.Raw err = bson.UnmarshalExtJSON(content, true, val) assert.Nil(mt, err, "UnmarshalExtJSON error for file %v: %v", file, err) return doc } func rawValueToCoreValue(rv bson.RawValue) bsoncore.Value { return bsoncore.Value{Type: rv.Type, Data: rv.Value} } type deadlockTest struct { clientTest mongo.Client clientKeyVaultOpts options.ClientOptions clientKeyVaultEvents []startedEvent clientEncryption mongo.ClientEncryption ciphertext primitive.Binary } type startedEvent struct { Command string Database string } func newDeadlockTest(mt mtest.T) deadlockTest { mt.Helper() var d deadlockTest var err error clientTestOpts := options.Client().ApplyURI(mtest.ClusterURI()).SetWriteConcern(mtest.MajorityWc) integtest.AddTestServerAPIVersion(clientTestOpts) if d.clientTest, err = mongo.Connect(context.Background(), clientTestOpts); err != nil { mt.Fatalf("Connect error: %v", err) } clientKeyVaultMonitor := &event.CommandMonitor{ Started: func(ctx context.Context, event event.CommandStartedEvent) { startedEvent := startedEvent{event.CommandName, event.DatabaseName} d.clientKeyVaultEvents = append(d.clientKeyVaultEvents, startedEvent) }, } d.clientKeyVaultOpts = options.Client().ApplyURI(mtest.ClusterURI()). SetMaxPoolSize(1).SetMonitor(clientKeyVaultMonitor) keyvaultColl := d.clientTest.Database("keyvault").Collection("datakeys") dataColl := d.clientTest.Database("db").Collection("coll") err = dataColl.Drop(context.Background()) assert.Nil(mt, err, "Drop error for collection db.coll: %v", err) err = keyvaultColl.Drop(context.Background()) assert.Nil(mt, err, "Drop error for key vault collection: %v", err) keyDoc := readJSONFile(mt, "external-key.json") _, err = keyvaultColl.InsertOne(context.Background(), keyDoc) assert.Nil(mt, err, "InsertOne error into key vault collection: %v", err) schemaDoc := readJSONFile(mt, "external-schema.json") createOpts := options.CreateCollection().SetValidator(bson.M{"$jsonSchema": schemaDoc}) err = d.clientTest.Database("db").CreateCollection(context.Background(), "coll", createOpts) assert.Nil(mt, err, "CreateCollection error: %v", err) kmsProviders := map[string]map[string]interface{}{ "local": {"key": localMasterKey}, } ceOpts := options.ClientEncryption().SetKmsProviders(kmsProviders).SetKeyVaultNamespace("keyvault.datakeys") d.clientEncryption, err = mongo.NewClientEncryption(d.clientTest, ceOpts) assert.Nil(mt, err, "NewClientEncryption error: %v", err) t, value, err := bson.MarshalValue("string0") assert.Nil(mt, err, "MarshalValue error: %v", err) in := bson.RawValue{Type: t, Value: value} eopts := options.Encrypt().SetAlgorithm("AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic").SetKeyAltName("local") d.ciphertext, err = d.clientEncryption.Encrypt(context.Background(), in, eopts) assert.Nil(mt, err, "Encrypt error: %v", err) return &d } func (d deadlockTest) disconnect(mt mtest.T) { mt.Helper() err := d.clientEncryption.Close(context.Background()) assert.Nil(mt, err, "clientEncryption Close error: %v", err) d.clientTest.Disconnect(context.Background()) assert.Nil(mt, err, "clientTest Disconnect error: %v", err) } // listenForConnections creates a listener that will listen for connections. // The user provided run function will be called with the accepted // connection. The user is responsible for calling Close on the returned listener. func listenForConnections(t testing.T, run func(net.Conn)) net.Listener { t.Helper() l, err := net.Listen("tcp", "localhost:0") if err != nil { t.Errorf("Could not set up a listener: %v", err) t.FailNow() } go func() { for { // Ignore errors due to closing the listener connection. c, _ := l.Accept() if c == nil { break } go run(c) } }() return l } type localTransport struct { rt http.RoundTripper header http.Header } func (t localTransport) RoundTrip(req http.Request) (*http.Response, error) { r := req.Clone(req.Context()) r.URL.Host = "localhost:8080" for key, vals := range t.header { for _, val := range vals { r.Header.Add(key, val) } } return t.rt.RoundTrip(r) }	127.68 KB	2025-05-25 12:27
📄 client_side_encryption_spec_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 //go:build cse // +build cse package integration import ( "os" "path" "regexp" "testing" ) const ( encryptionSpecName = "client-side-encryption/legacy" ) func verifyClientSideEncryptionVarsSet(t testing.T) { t.Helper() // Existence of temporary AWS credentials (awsTempAccessKeyID, awsTempSessionToken and // awsTempSessionToken) is verified when the variables are used in json_helpers_test // because temporary AWS credentials are not always set. if awsAccessKeyID == "" { t.Fatal("AWS access key ID not set") } if awsSecretAccessKey == "" { t.Fatal("AWS secret access key not set") } if azureTenantID == "" { t.Fatal("azure tenant ID not set") } if azureClientID == "" { t.Fatal("azure client ID not set") } if azureClientSecret == "" { t.Fatal("azure client secret not set") } if gcpEmail == "" { t.Fatal("GCP email not set") } if gcpPrivateKey == "" { t.Fatal("GCP private key not set") } } func TestClientSideEncryptionSpec(t testing.T) { verifyClientSideEncryptionVarsSet(t) for _, fileName := range jsonFilesInDir(t, path.Join(dataPath, encryptionSpecName)) { t.Run(fileName, func(t testing.T) { re := regexp.MustCompile(`fle2\-Range\-.\-Correctness`) if re.Match([]byte(fileName)) { t.Skipf("skipping test on macOS due to slow runtime") } if fileName == "kmipKMS.json" && "" == os.Getenv("KMS_MOCK_SERVERS_RUNNING") { t.Skipf("Skipping test as KMS_MOCK_SERVERS_RUNNING is not set") } runSpecTestFile(t, encryptionSpecName, fileName) }) } }	1.76 KB	2025-05-25 12:27
📄 client_side_encryption_test.go // Copyright (C) MongoDB, Inc. 2021-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 //go:build cse // +build cse package integration import ( "context" "testing" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/integtest" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" "go.mongodb.org/mongo-driver/x/mongo/driver" mcopts "go.mongodb.org/mongo-driver/x/mongo/driver/mongocrypt/options" ) // createDataKeyAndEncrypt creates a data key with the alternate name @keyName. // Returns a ciphertext encrypted with the data key as test data. func createDataKeyAndEncrypt(mt mtest.T, keyName string) primitive.Binary { mt.Helper() kvClientOpts := options.Client(). ApplyURI(mtest.ClusterURI()). SetReadConcern(mtest.MajorityRc). SetWriteConcern(mtest.MajorityWc) integtest.AddTestServerAPIVersion(kvClientOpts) kmsProvidersMap := map[string]map[string]interface{}{ "local": {"key": localMasterKey}, } kvClient, err := mongo.Connect(context.Background(), kvClientOpts) defer kvClient.Disconnect(context.Background()) assert.Nil(mt, err, "Connect error: %v", err) err = kvClient.Database("keyvault").Collection("datakeys").Drop(context.Background()) assert.Nil(mt, err, "Drop error: %v", err) ceOpts := options.ClientEncryption(). SetKmsProviders(kmsProvidersMap). SetKeyVaultNamespace("keyvault.datakeys") ce, err := mongo.NewClientEncryption(kvClient, ceOpts) assert.Nil(mt, err, "NewClientEncryption error: %v", err) dkOpts := options.DataKey().SetKeyAltNames([]string{keyName}) _, err = ce.CreateDataKey(context.Background(), "local", dkOpts) assert.Nil(mt, err, "CreateDataKey error: %v", err) in := bson.RawValue{Type: bsontype.String, Value: bsoncore.AppendString(nil, "test")} eOpts := options.Encrypt(). SetAlgorithm("AEAD_AES_256_CBC_HMAC_SHA_512-Random"). SetKeyAltName(keyName) ciphertext, err := ce.Encrypt(context.Background(), in, eOpts) assert.Nil(mt, err, "Encrypt error: %v", err) return ciphertext } func getLsid(mt mtest.T, doc bson.Raw) bson.Raw { mt.Helper() lsid, err := doc.LookupErr("lsid") assert.Nil(mt, err, "expected lsid in document: %v", doc) lsidDoc, ok := lsid.DocumentOK() assert.True(mt, ok, "expected lsid to be document, but got: %v", lsid) return lsidDoc } func makeMonitor(mt mtest.T, captured []event.CommandStartedEvent) event.CommandMonitor { mt.Helper() assert.NotNil(mt, captured, "captured is nil") return &event.CommandMonitor{ Started: func(_ context.Context, cse event.CommandStartedEvent) { assert.NotNil(mt, cse, "expected non-Nil CommandStartedEvent") captured = append(captured, cse) }, } } func TestClientSideEncryptionWithExplicitSessions(t testing.T) { verifyClientSideEncryptionVarsSet(t) mt := mtest.New(t, mtest.NewOptions().MinServerVersion("4.2").Enterprise(true).CreateClient(false)) kmsProvidersMap := map[string]map[string]interface{}{ "local": {"key": localMasterKey}, } schema := bson.D{ {"bsonType", "object"}, {"properties", bson.D{ {"encryptMe", bson.D{ {"encrypt", bson.D{ {"keyId", "/keyName"}, {"bsonType", "string"}, {"algorithm", "AEAD_AES_256_CBC_HMAC_SHA_512-Random"}, }}, }}, }}, } schemaMap := map[string]interface{}{"db.coll": schema} mt.Run("automatic encryption", func(mt mtest.T) { createDataKeyAndEncrypt(mt, "myKey") aeOpts := options.AutoEncryption(). SetKmsProviders(kmsProvidersMap). SetKeyVaultNamespace("keyvault.datakeys"). SetSchemaMap(schemaMap). SetExtraOptions(getCryptSharedLibExtraOptions()) var capturedEvents []event.CommandStartedEvent clientOpts := options.Client(). ApplyURI(mtest.ClusterURI()). SetReadConcern(mtest.MajorityRc). SetWriteConcern(mtest.MajorityWc). SetAutoEncryptionOptions(aeOpts). SetMonitor(makeMonitor(mt, &capturedEvents)) integtest.AddTestServerAPIVersion(clientOpts) client, err := mongo.Connect(context.Background(), clientOpts) assert.Nil(mt, err, "Connect error: %v", err) defer client.Disconnect(context.Background()) coll := client.Database("db").Collection("coll") err = coll.Drop(context.Background()) assert.Nil(mt, err, "Drop error: %v", err) session, err := client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) sessionCtx := mongo.NewSessionContext(context.Background(), session) capturedEvents = make([]event.CommandStartedEvent, 0) _, err = coll.InsertOne(sessionCtx, bson.D{{"encryptMe", "test"}, {"keyName", "myKey"}}) assert.Nil(mt, err, "InsertOne error: %v", err) assert.Equal(mt, len(capturedEvents), 2, "expected 2 events, got %v", len(capturedEvents)) // Assert the first event is a find on the keyvault.datakeys collection. event := capturedEvents[0] assert.Equal(mt, event.CommandName, "find", "expected command find, got %q", event.CommandName) assert.Equal(mt, event.DatabaseName, "keyvault", "expected find on keyvault, got %q", event.DatabaseName) // Assert the find used an implicit session with an lsid != session.ID() lsid := getLsid(mt, event.Command) assert.Nil(mt, err, "lsid not found in %v", event.Command) assert.NotEqual(mt, lsid, session.ID(), "expected different lsid, but got %v", lsid) // Assert the second event is the original insert. event = capturedEvents[1] assert.Equal(mt, event.CommandName, "insert", "expected command insert, got %q", event.CommandName) // Assert the insert used the explicit session. lsid = getLsid(mt, event.Command) assert.Nil(mt, err, "lsid not found on %v", event.Command) assert.Equal(mt, lsid, session.ID(), "expected lsid %v, but got %v", session.ID(), lsid) // Check that encryptMe is encrypted. encryptMe, err := event.Command.LookupErr("documents", "0", "encryptMe") assert.Nil(mt, err, "could not find encryptMe in %v", event.Command) assert.Equal(mt, encryptMe.Type, bson.TypeBinary, "expected Binary, got %v", encryptMe.Type) }) mt.Run("automatic decryption", func(mt mtest.T) { ciphertext := createDataKeyAndEncrypt(mt, "myKey") aeOpts := options.AutoEncryption(). SetKmsProviders(kmsProvidersMap). SetKeyVaultNamespace("keyvault.datakeys"). SetBypassAutoEncryption(true) var capturedEvents []event.CommandStartedEvent clientOpts := options.Client(). ApplyURI(mtest.ClusterURI()). SetReadConcern(mtest.MajorityRc). SetWriteConcern(mtest.MajorityWc). SetAutoEncryptionOptions(aeOpts). SetMonitor(makeMonitor(mt, &capturedEvents)) integtest.AddTestServerAPIVersion(clientOpts) client, err := mongo.Connect(context.Background(), clientOpts) assert.Nil(mt, err, "Connect error: %v", err) defer client.Disconnect(context.Background()) coll := client.Database("db").Collection("coll") err = coll.Drop(context.Background()) assert.Nil(mt, err, "Drop error: %v", err) _, err = coll.InsertOne(context.Background(), bson.D{{"encryptMe", ciphertext}}) assert.Nil(mt, err, "InsertOne error: %v", err) session, err := client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) sessionCtx := mongo.NewSessionContext(context.Background(), session) capturedEvents = make([]event.CommandStartedEvent, 0) res := coll.FindOne(sessionCtx, bson.D{{}}) assert.Nil(mt, res.Err(), "FindOne error: %v", res.Err()) assert.Equal(mt, len(capturedEvents), 2, "expected 2 events, got %v", len(capturedEvents)) // Assert the first event is the original find. event := capturedEvents[0] assert.Equal(mt, event.CommandName, "find", "expected command find, got %q", event.CommandName) assert.Equal(mt, event.DatabaseName, "db", "expected find on db, got %q", event.DatabaseName) // Assert the find used the explicit session lsid := getLsid(mt, event.Command) assert.Nil(mt, err, "lsid not found on %v", event.Command) assert.Equal(mt, lsid, session.ID(), "expected lsid %v, but got %v", session.ID(), lsid) // Assert the second event is the find on the keyvault.datakeys collection. event = capturedEvents[1] assert.Equal(mt, event.CommandName, "find", "expected command find, got %q", event.CommandName) assert.Equal(mt, event.DatabaseName, "keyvault", "expected find on keyvault, got %q", event.DatabaseName) // Assert the find used an implicit session with an lsid != session.ID() lsid = getLsid(mt, event.Command) assert.Nil(mt, err, "lsid not found on %v", event.Command) assert.NotEqual(mt, lsid, session.ID(), "expected different lsid, but got %v", lsid) }) } // customCrypt is a test implementation of the driver.Crypt interface. It keeps track of the number of times its // methods have been called. type customCrypt struct { numEncryptCalls int numDecryptCalls int numCreateDataKeyCalls int numEncryptExplicitCalls int numEncryptExplicitExpressionCalls int numDecryptExplicitCalls int numCloseCalls int numBypassAutoEncryptionCalls int numRewrapDataKeyCalls int } var ( _ driver.Crypt = (customCrypt)(nil) mySSN = "123456789" ) // Encrypt encrypts the given command. func (c customCrypt) Encrypt(_ context.Context, _ string, cmd bsoncore.Document) (bsoncore.Document, error) { c.numEncryptCalls++ elems, err := cmd.Elements() if err != nil { return nil, err } encryptedCmd := bsoncore.NewDocumentBuilder() for _, elem := range elems { // "encrypt" ssn element as "hidden" if elem.Key() == "ssn" { encryptedCmd = encryptedCmd.AppendString("ssn", "hidden") } else { encryptedCmd = encryptedCmd.AppendValue(elem.Key(), elem.Value()) } } return encryptedCmd.Build(), nil } // Decrypt decrypts the given command response. func (c customCrypt) Decrypt(_ context.Context, cmdResponse bsoncore.Document) (bsoncore.Document, error) { c.numDecryptCalls++ elems, err := cmdResponse.Elements() if err != nil { return nil, err } decryptedCmdResponse := bsoncore.NewDocumentBuilder() for _, elem := range elems { // "decrypt" ssn element as mySSN if elem.Key() == "ssn" { decryptedCmdResponse = decryptedCmdResponse.AppendString("ssn", mySSN) } else { decryptedCmdResponse = decryptedCmdResponse.AppendValue(elem.Key(), elem.Value()) } } return decryptedCmdResponse.Build(), nil } // CreateDataKey implements the driver.Crypt interface. func (c customCrypt) CreateDataKey(_ context.Context, _ string, _ mcopts.DataKeyOptions) (bsoncore.Document, error) { c.numCreateDataKeyCalls++ return nil, nil } // EncryptExplicit implements the driver.Crypt interface. func (c customCrypt) EncryptExplicit(_ context.Context, _ bsoncore.Value, _ mcopts.ExplicitEncryptionOptions) (byte, []byte, error) { c.numEncryptExplicitCalls++ return 0, nil, nil } // EncryptExplicit implements the driver.Crypt interface. func (c customCrypt) EncryptExplicitExpression(_ context.Context, _ bsoncore.Document, _ mcopts.ExplicitEncryptionOptions) (bsoncore.Document, error) { c.numEncryptExplicitExpressionCalls++ return nil, nil } // DecryptExplicit implements the driver.Crypt interface. func (c customCrypt) DecryptExplicit(_ context.Context, _ byte, _ []byte) (bsoncore.Value, error) { c.numDecryptExplicitCalls++ return bsoncore.Value{}, nil } // Close implements the driver.Crypt interface. func (c customCrypt) Close() { c.numCloseCalls++ } // BypassAutoEncryption implements the driver.Crypt interface. func (c customCrypt) BypassAutoEncryption() bool { c.numBypassAutoEncryptionCalls++ return false } // RewrapDataKey attempts to rewrap the document data keys matching the filter, preparing the re-wrapped documents to // be returned as a slice of bsoncore.Document. func (c customCrypt) RewrapDataKey(_ context.Context, _ []byte, _ mcopts.RewrapManyDataKeyOptions) ([]bsoncore.Document, error) { c.numRewrapDataKeyCalls++ return nil, nil } func TestClientSideEncryptionCustomCrypt(t testing.T) { mt := mtest.New(t, mtest.NewOptions().MinServerVersion("4.2").Enterprise(true).CreateClient(false)) kmsProvidersMap := map[string]map[string]interface{}{ "local": {"key": localMasterKey}, } mt.Run("auto encryption and decryption", func(mt mtest.T) { aeOpts := options.AutoEncryption(). SetKmsProviders(kmsProvidersMap). SetKeyVaultNamespace("keyvault.datakeys"). SetExtraOptions(getCryptSharedLibExtraOptions()) clientOpts := options.Client(). ApplyURI(mtest.ClusterURI()). SetAutoEncryptionOptions(aeOpts) cc := &customCrypt{} clientOpts.Crypt = cc integtest.AddTestServerAPIVersion(clientOpts) client, err := mongo.Connect(context.Background(), clientOpts) defer client.Disconnect(context.Background()) assert.Nil(mt, err, "Connect error: %v", err) coll := client.Database("db").Collection("coll") defer func() { _ = coll.Drop(context.Background()) }() doc := bson.D{{"foo", "bar"}, {"ssn", mySSN}} _, err = coll.InsertOne(context.Background(), doc) assert.Nil(mt, err, "InsertOne error: %v", err) res := coll.FindOne(context.Background(), bson.D{{"foo", "bar"}}) assert.Nil(mt, res.Err(), "FindOne error: %v", err) rawRes, err := res.Raw() assert.Nil(mt, err, "Raw error: %v", err) ssn, ok := rawRes.Lookup("ssn").StringValueOK() assert.True(mt, ok, "expected 'ssn' value to be type string, got %T", ssn) assert.Equal(mt, ssn, mySSN, "expected 'ssn' value %q, got %q", mySSN, ssn) // Assert customCrypt methods are called the correct number of times. assert.Equal(mt, cc.numEncryptCalls, 1, "expected 1 call to Encrypt, got %v", cc.numEncryptCalls) assert.Equal(mt, cc.numDecryptCalls, 1, "expected 1 call to Decrypt, got %v", cc.numDecryptCalls) assert.Equal(mt, cc.numCreateDataKeyCalls, 0, "expected 0 calls to CreateDataKey, got %v", cc.numCreateDataKeyCalls) assert.Equal(mt, cc.numEncryptExplicitCalls, 0, "expected 0 calls to EncryptExplicit, got %v", cc.numEncryptExplicitCalls) assert.Equal(mt, cc.numEncryptExplicitExpressionCalls, 0, "expected 0 calls to EncryptExplicitExpression, got %v", cc.numEncryptExplicitExpressionCalls) assert.Equal(mt, cc.numDecryptExplicitCalls, 0, "expected 0 calls to DecryptExplicit, got %v", cc.numDecryptExplicitCalls) assert.Equal(mt, cc.numCloseCalls, 0, "expected 0 calls to Close, got %v", cc.numCloseCalls) assert.Equal(mt, cc.numBypassAutoEncryptionCalls, 2, "expected 2 calls to BypassAutoEncryption, got %v", cc.numBypassAutoEncryptionCalls) }) } func TestFLE2CreateCollection(t testing.T) { // FLE 2 (aka Queryable Encryption) is not supported on Standalone topology. mtOpts := mtest.NewOptions(). MinServerVersion("7.0"). Enterprise(true). CreateClient(false). Topologies(mtest.ReplicaSet, mtest.Sharded, mtest.LoadBalanced, mtest.ShardedReplicaSet) mt := mtest.New(t, mtOpts) efJSON := ` { "escCollection": "enxcol_.encryptedCollection.esc", "ecocCollection": "enxcol_.encryptedCollection.ecoc", "fields": [ { "path": "firstName", "bsonType": "string", "keyId": { "$binary": { "subType": "04", "base64": "AAAAAAAAAAAAAAAAAAAAAA==" } } } ] } ` var efBSON bson.Raw err := bson.UnmarshalExtJSON([]byte(efJSON), true / canonical /, &efBSON) assert.Nil(mt, err, "UnmarshalExtJSON error: %v", err) // Test the behavior in the specification test fle2-CreateCollection.json: "CreateCollection from encryptedFields.". // The Go driver does not support encryptedFields as an option to Drop. See: GODRIVER-2413. mt.Run("CreateCollection from encryptedFields", func(mt mtest.T) { // Drop data and state collections to clean up from a prior test run. { err = mt.DB.Collection("enxcol_.encryptedCollection.esc").Drop(context.Background()) assert.Nil(mt, err, "error in Drop: %v", err) err = mt.DB.Collection("enxcol_.encryptedCollection.ecoc").Drop(context.Background()) assert.Nil(mt, err, "error in Drop: %v", err) err := mt.DB.Collection("coll").Drop(context.Background()) assert.Nil(mt, err, "error in Drop: %v", err) } mt.DB.CreateCollection(context.Background(), "coll", options.CreateCollection().SetEncryptedFields(efBSON)) // Check expected collections and index exist. { got, err := mt.DB.ListCollectionNames(context.Background(), bson.D{{"name", "coll"}}) assert.Nil(mt, err, "error in ListCollectionNames") assert.Equal(mt, got, []string{"coll"}, "expected ['coll'], got: %v", got) got, err = mt.DB.ListCollectionNames(context.Background(), bson.D{{"name", "enxcol_.encryptedCollection.esc"}}) assert.Nil(mt, err, "error in ListCollectionNames") assert.Equal(mt, got, []string{"enxcol_.encryptedCollection.esc"}, "expected ['encryptedCollection.esc'], got: %v", got) got, err = mt.DB.ListCollectionNames(context.Background(), bson.D{{"name", "enxcol_.encryptedCollection.ecoc"}}) assert.Nil(mt, err, "error in ListCollectionNames") assert.Equal(mt, got, []string{"enxcol_.encryptedCollection.ecoc"}, "expected ['encryptedCollection.ecoc'], got: %v", got) indexSpecs, err := mt.DB.Collection("coll").Indexes().ListSpecifications(context.Background()) assert.Nil(mt, err, "error in Indexes().ListSpecifications: %v", err) assert.Equal(mt, len(indexSpecs), 2, "expected two indexes on 'coll', got: %v", indexSpecs) assert.Equal(mt, indexSpecs[1].Name, "__safeContent___1", "expected second index to be '__safeContent___1', got %v", indexSpecs[1].Name) } }) } func TestFLE2DocsExample(t testing.T) { // FLE 2 is not supported on Standalone topology. // Only test MongoDB Server 7.0+. MongoDB Server 7.0 introduced a backwards breaking change to the Queryable Encryption (QE) protocol: QEv2. // libmongocrypt is configured to use the QEv2 protocol. mtOpts := mtest.NewOptions(). MinServerVersion("7.0"). Enterprise(true). CreateClient(false). Topologies(mtest.ReplicaSet, mtest.Sharded, mtest.LoadBalanced, mtest.ShardedReplicaSet) mt := mtest.New(t, mtOpts) mt.Run("Auto Encryption", func(mt mtest.T) { // Drop data from prior test runs. { err := mt.Client.Database("keyvault").Collection("datakeys").Drop(context.Background()) assert.Nil(mt, err, "error in Drop: %v", err) err = mt.Client.Database("docsExamples").Drop(context.Background()) assert.Nil(mt, err, "error in Drop: %v", err) } kmsProvidersMap := map[string]map[string]interface{}{ "local": {"key": localMasterKey}, } var key1ID primitive.Binary var key2ID primitive.Binary // Create two data keys. { cOpts := options.Client().ApplyURI(mtest.ClusterURI()) integtest.AddTestServerAPIVersion(cOpts) keyVaultClient, err := mongo.Connect(context.Background(), cOpts) assert.Nil(mt, err, "error in Connect: %v", err) defer keyVaultClient.Disconnect(context.Background()) ceOpts := options.ClientEncryption().SetKmsProviders(kmsProvidersMap).SetKeyVaultNamespace("keyvault.datakeys") ce, err := mongo.NewClientEncryption(keyVaultClient, ceOpts) assert.Nil(mt, err, "error in NewClientEncryption: %v", err) defer ce.Close(context.Background()) key1ID, err = ce.CreateDataKey(context.Background(), "local") assert.Nil(mt, err, "error in CreateDataKey: %v", err) key2ID, err = ce.CreateDataKey(context.Background(), "local") assert.Nil(mt, err, "error in CreateDataKey: %v", err) } // Create an encryptedFieldsMap. encryptedFieldsMap := bson.M{ "docsExamples.encrypted": bson.M{ "fields": []bson.M{ { "path": "encryptedIndexed", "bsonType": "string", "keyId": key1ID, "queries": []bson.M{ { "queryType": "equality", }, }, }, { "path": "encryptedUnindexed", "bsonType": "string", "keyId": key2ID, }, }, }, } // Create an FLE 2 collection. var encryptedColl *mongo.Collection { cOpts := options.Client().ApplyURI(mtest.ClusterURI()) integtest.AddTestServerAPIVersion(cOpts) aeOpts := options.AutoEncryption().SetKmsProviders(kmsProvidersMap).SetKeyVaultNamespace("keyvault.datakeys").SetEncryptedFieldsMap(encryptedFieldsMap).SetExtraOptions(getCryptSharedLibExtraOptions()) cOpts.SetAutoEncryptionOptions(aeOpts) encryptedClient, err := mongo.Connect(context.Background(), cOpts) defer encryptedClient.Disconnect(context.Background()) assert.Nil(mt, err, "error in Connect: %v", err) // Create the FLE 2 collection docsExample.encrypted. db := encryptedClient.Database("docsExamples") // Because docsExample.encrypted is in encryptedFieldsMap, it is created with FLE 2 support. err = db.CreateCollection(context.Background(), "encrypted") assert.Nil(mt, err, "error in CreateCollection") encryptedColl = db.Collection("encrypted") } // Auto encrypt an insert and find. { // Encrypt an insert. _, err := encryptedColl.InsertOne(context.Background(), bson.M{ "_id": 1, "encryptedIndexed": "indexedValue", "encryptedUnindexed": "unindexedValue", }) assert.Nil(mt, err, "error in InsertOne") // Encrypt a find. res := encryptedColl.FindOne(context.Background(), bson.M{ "encryptedIndexed": "indexedValue", }) assert.Nil(mt, res.Err(), "error in FindOne: %v", res.Err()) var resBSON bson.M err = res.Decode(&resBSON) assert.Nil(mt, err, "error in Decode: %v", err) assert.Equal(mt, resBSON["encryptedIndexed"], "indexedValue", "expected 'indexedValue', got %q", resBSON["encryptedIndexed"]) assert.Equal(mt, resBSON["encryptedUnindexed"], "unindexedValue", "expected 'unindexedValue', got %q", resBSON["encryptedUnindexed"]) } // Find documents without decryption. { unencryptedColl := mt.Client.Database("docsExamples").Collection("encrypted") res := unencryptedColl.FindOne(context.Background(), bson.M{"_id": 1}) assert.Nil(mt, res.Err(), "error in FindOne: %v", res.Err()) resBSON, err := res.Raw() assert.Nil(mt, err, "error in Raw: %v", err) val := resBSON.Lookup("encryptedIndexed") assert.Equal(mt, val.Type, bsontype.Binary, "expected encryptedIndexed to be Binary, got %v", val.Type) val = resBSON.Lookup("encryptedUnindexed") assert.Equal(mt, val.Type, bsontype.Binary, "expected encryptedUnindexed to be Binary, got %v", val.Type) } }) }	22.17 KB	2025-05-25 12:27
📄 client_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "fmt" "net" "os" "reflect" "strings" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsonrw" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/eventtest" "go.mongodb.org/mongo-driver/internal/handshake" "go.mongodb.org/mongo-driver/internal/integtest" "go.mongodb.org/mongo-driver/internal/require" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/mongo/readpref" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" "go.mongodb.org/mongo-driver/x/mongo/driver" "go.mongodb.org/mongo-driver/x/mongo/driver/wiremessage" "golang.org/x/sync/errgroup" ) var noClientOpts = mtest.NewOptions().CreateClient(false) type negateCodec struct { ID int64 `bson:"_id"` } func (e negateCodec) EncodeValue(_ bsoncodec.EncodeContext, vw bsonrw.ValueWriter, val reflect.Value) error { return vw.WriteInt64(val.Int()) } // DecodeValue negates the value of ID when reading func (e negateCodec) DecodeValue(_ bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error { i, err := vr.ReadInt64() if err != nil { return err } val.SetInt(i * -1) return nil } var _ options.ContextDialer = &slowConnDialer{} // A slowConnDialer dials connections that delay network round trips by the given delay duration. type slowConnDialer struct { dialer net.Dialer delay time.Duration } var slowConnDialerDelay = 300 time.Millisecond var reducedHeartbeatInterval = 100 * time.Millisecond func newSlowConnDialer(delay time.Duration) slowConnDialer { return &slowConnDialer{ dialer: &net.Dialer{}, delay: delay, } } func (scd slowConnDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) { conn, err := scd.dialer.DialContext(ctx, network, address) if err != nil { return nil, err } return &slowConn{ Conn: conn, delay: scd.delay, }, nil } var _ net.Conn = &slowConn{} // slowConn is a net.Conn that delays all calls to Read() by given delay durations. All other // net.Conn functions behave identically to the embedded net.Conn. type slowConn struct { net.Conn delay time.Duration } func (sc slowConn) Read(b []byte) (n int, err error) { time.Sleep(sc.delay) return sc.Conn.Read(b) } func TestClient(t testing.T) { mt := mtest.New(t, noClientOpts) registryOpts := options.Client(). SetRegistry(bson.NewRegistryBuilder().RegisterCodec(reflect.TypeOf(int64(0)), &negateCodec{}).Build()) mt.RunOpts("registry passed to cursors", mtest.NewOptions().ClientOptions(registryOpts), func(mt mtest.T) { _, err := mt.Coll.InsertOne(context.Background(), negateCodec{ID: 10}) assert.Nil(mt, err, "InsertOne error: %v", err) var got negateCodec err = mt.Coll.FindOne(context.Background(), bson.D{}).Decode(&got) assert.Nil(mt, err, "Find error: %v", err) assert.Equal(mt, int64(-10), got.ID, "expected ID -10, got %v", got.ID) }) mt.RunOpts("tls connection", mtest.NewOptions().MinServerVersion("3.0").SSL(true), func(mt mtest.T) { var result bson.Raw err := mt.Coll.Database().RunCommand(context.Background(), bson.D{ {"serverStatus", 1}, }).Decode(&result) assert.Nil(mt, err, "serverStatus error: %v", err) security := result.Lookup("security") assert.Equal(mt, bson.TypeEmbeddedDocument, security.Type, "expected security field to be type %v, got %v", bson.TypeMaxKey, security.Type) _, found := security.Document().LookupErr("SSLServerSubjectName") assert.Nil(mt, found, "SSLServerSubjectName not found in result") }) mt.RunOpts("x509", mtest.NewOptions().Auth(true).SSL(true), func(mt mtest.T) { testCases := []struct { certificate string password string }{ { "MONGO_GO_DRIVER_KEY_FILE", "", }, { "MONGO_GO_DRIVER_PKCS8_ENCRYPTED_KEY_FILE", "&sslClientCertificateKeyPassword=password", }, { "MONGO_GO_DRIVER_PKCS8_UNENCRYPTED_KEY_FILE", "", }, } for _, tc := range testCases { mt.Run(tc.certificate, func(mt mtest.T) { const user = "C=US,ST=New York,L=New York City,O=MDB,OU=Drivers,CN=client" db := mt.Client.Database("$external") // We don't care if the user doesn't already exist. _ = db.RunCommand( context.Background(), bson.D{{"dropUser", user}}, ) err := db.RunCommand( context.Background(), bson.D{ {"createUser", user}, {"roles", bson.A{ bson.D{{"role", "readWrite"}, {"db", "test"}}, }}, }, ).Err() assert.Nil(mt, err, "createUser error: %v", err) baseConnString := mtest.ClusterURI() // remove username/password from base conn string revisedConnString := "mongodb://" split := strings.Split(baseConnString, "@") assert.Equal(t, 2, len(split), "expected 2 parts after split, got %v (connstring %v)", split, baseConnString) revisedConnString += split[1] cs := fmt.Sprintf( "%s&sslClientCertificateKeyFile=%s&authMechanism=MONGODB-X509&authSource=$external%s", revisedConnString, os.Getenv(tc.certificate), tc.password, ) authClientOpts := options.Client().ApplyURI(cs) integtest.AddTestServerAPIVersion(authClientOpts) authClient, err := mongo.Connect(context.Background(), authClientOpts) assert.Nil(mt, err, "authClient Connect error: %v", err) defer func() { _ = authClient.Disconnect(context.Background()) }() rdr, err := authClient.Database("test").RunCommand(context.Background(), bson.D{ {"connectionStatus", 1}, }).Raw() assert.Nil(mt, err, "connectionStatus error: %v", err) users, err := rdr.LookupErr("authInfo", "authenticatedUsers") assert.Nil(mt, err, "authenticatedUsers not found in response") elems, err := users.Array().Elements() assert.Nil(mt, err, "error getting users elements: %v", err) for _, userElem := range elems { rdr := userElem.Value().Document() var u struct { User string DB string } if err := bson.Unmarshal(rdr, &u); err != nil { continue } if u.User == user && u.DB == "$external" { return } } mt.Fatal("unable to find authenticated user") }) } }) mt.RunOpts("list databases", noClientOpts, func(mt mtest.T) { mt.RunOpts("filter", noClientOpts, func(mt mtest.T) { testCases := []struct { name string filter bson.D hasTestDb bool minServerVersion string }{ {"empty", bson.D{}, true, ""}, {"non-empty", bson.D{{"name", "foobar"}}, false, "3.6"}, } for _, tc := range testCases { opts := mtest.NewOptions() if tc.minServerVersion != "" { opts.MinServerVersion(tc.minServerVersion) } mt.RunOpts(tc.name, opts, func(mt mtest.T) { res, err := mt.Client.ListDatabases(context.Background(), tc.filter) assert.Nil(mt, err, "ListDatabases error: %v", err) var found bool for _, db := range res.Databases { if db.Name == mtest.TestDb { found = true break } } assert.Equal(mt, tc.hasTestDb, found, "expected to find test db: %v, found: %v", tc.hasTestDb, found) }) } }) mt.Run("options", func(mt mtest.T) { allOpts := options.ListDatabases().SetNameOnly(true).SetAuthorizedDatabases(true) mt.ClearEvents() _, err := mt.Client.ListDatabases(context.Background(), bson.D{}, allOpts) assert.Nil(mt, err, "ListDatabases error: %v", err) evt := mt.GetStartedEvent() assert.Equal(mt, "listDatabases", evt.CommandName, "expected ") expectedDoc := bsoncore.BuildDocumentFromElements(nil, bsoncore.AppendBooleanElement(nil, "nameOnly", true), bsoncore.AppendBooleanElement(nil, "authorizedDatabases", true), ) err = compareDocs(mt, expectedDoc, evt.Command) assert.Nil(mt, err, "compareDocs error: %v", err) }) }) mt.RunOpts("list database names", noClientOpts, func(mt mtest.T) { mt.RunOpts("filter", noClientOpts, func(mt mtest.T) { testCases := []struct { name string filter bson.D hasTestDb bool minServerVersion string }{ {"no filter", bson.D{}, true, ""}, {"filter", bson.D{{"name", "foobar"}}, false, "3.6"}, } for _, tc := range testCases { opts := mtest.NewOptions() if tc.minServerVersion != "" { opts.MinServerVersion(tc.minServerVersion) } mt.RunOpts(tc.name, opts, func(mt mtest.T) { dbs, err := mt.Client.ListDatabaseNames(context.Background(), tc.filter) assert.Nil(mt, err, "ListDatabaseNames error: %v", err) var found bool for _, db := range dbs { if db == mtest.TestDb { found = true break } } assert.Equal(mt, tc.hasTestDb, found, "expected to find test db: %v, found: %v", tc.hasTestDb, found) }) } }) mt.Run("options", func(mt mtest.T) { allOpts := options.ListDatabases().SetNameOnly(true).SetAuthorizedDatabases(true) mt.ClearEvents() _, err := mt.Client.ListDatabaseNames(context.Background(), bson.D{}, allOpts) assert.Nil(mt, err, "ListDatabaseNames error: %v", err) evt := mt.GetStartedEvent() assert.Equal(mt, "listDatabases", evt.CommandName, "expected ") expectedDoc := bsoncore.BuildDocumentFromElements(nil, bsoncore.AppendBooleanElement(nil, "nameOnly", true), bsoncore.AppendBooleanElement(nil, "authorizedDatabases", true), ) err = compareDocs(mt, expectedDoc, evt.Command) assert.Nil(mt, err, "compareDocs error: %v", err) }) }) mt.RunOpts("ping", noClientOpts, func(mt mtest.T) { mt.Run("default read preference", func(mt mtest.T) { err := mt.Client.Ping(context.Background(), nil) assert.Nil(mt, err, "Ping error: %v", err) }) mt.Run("invalid host", func(mt mtest.T) { // manually create client rather than using RunOpts with ClientOptions because the testing lib will // apply the correct URI. invalidClientOpts := options.Client(). SetServerSelectionTimeout(100 time.Millisecond).SetHosts([]string{"invalid:123"}). SetConnectTimeout(500 * time.Millisecond).SetSocketTimeout(500 * time.Millisecond) integtest.AddTestServerAPIVersion(invalidClientOpts) client, err := mongo.Connect(context.Background(), invalidClientOpts) assert.Nil(mt, err, "Connect error: %v", err) err = client.Ping(context.Background(), readpref.Primary()) assert.NotNil(mt, err, "expected error for pinging invalid host, got nil") _ = client.Disconnect(context.Background()) }) }) mt.RunOpts("disconnect", noClientOpts, func(mt mtest.T) { mt.Run("nil context", func(mt mtest.T) { err := mt.Client.Disconnect(nil) assert.Nil(mt, err, "Disconnect error: %v", err) }) }) mt.RunOpts("watch", noClientOpts, func(mt mtest.T) { mt.Run("disconnected", func(mt mtest.T) { c, err := mongo.NewClient(options.Client().ApplyURI(mtest.ClusterURI())) assert.Nil(mt, err, "NewClient error: %v", err) _, err = c.Watch(context.Background(), mongo.Pipeline{}) assert.Equal(mt, mongo.ErrClientDisconnected, err, "expected error %v, got %v", mongo.ErrClientDisconnected, err) }) }) mt.RunOpts("end sessions", mtest.NewOptions().MinServerVersion("3.6"), func(mt mtest.T) { _, err := mt.Client.ListDatabases(context.Background(), bson.D{}) assert.Nil(mt, err, "ListDatabases error: %v", err) mt.ClearEvents() err = mt.Client.Disconnect(context.Background()) assert.Nil(mt, err, "Disconnect error: %v", err) started := mt.GetStartedEvent() assert.Equal(mt, "endSessions", started.CommandName, "expected cmd name endSessions, got %v", started.CommandName) }) mt.RunOpts("hello lastWriteDate", mtest.NewOptions().Topologies(mtest.ReplicaSet), func(mt mtest.T) { _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"x", 1}}) assert.Nil(mt, err, "InsertOne error: %v", err) }) sessionOpts := mtest.NewOptions().MinServerVersion("3.6.0").CreateClient(false) mt.RunOpts("causal consistency", sessionOpts, func(mt mtest.T) { testCases := []struct { name string opts options.SessionOptions consistent bool }{ {"default", options.Session(), true}, {"true", options.Session().SetCausalConsistency(true), true}, {"false", options.Session().SetCausalConsistency(false), false}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { sess, err := mt.Client.StartSession(tc.opts) assert.Nil(mt, err, "StartSession error: %v", err) defer sess.EndSession(context.Background()) xs := sess.(mongo.XSession) consistent := xs.ClientSession().Consistent assert.Equal(mt, tc.consistent, consistent, "expected consistent to be %v, got %v", tc.consistent, consistent) }) } }) retryOpts := mtest.NewOptions().MinServerVersion("3.6.0").ClientType(mtest.Mock) mt.RunOpts("retry writes error 20 wrapped", retryOpts, func(mt mtest.T) { writeErrorCode20 := mtest.CreateWriteErrorsResponse(mtest.WriteError{ Message: "Transaction numbers", Code: 20, }) writeErrorCode19 := mtest.CreateWriteErrorsResponse(mtest.WriteError{ Message: "Transaction numbers", Code: 19, }) writeErrorCode20WrongMsg := mtest.CreateWriteErrorsResponse(mtest.WriteError{ Message: "Not transaction numbers", Code: 20, }) cmdErrCode20 := mtest.CreateCommandErrorResponse(mtest.CommandError{ Message: "Transaction numbers", Code: 20, }) cmdErrCode19 := mtest.CreateCommandErrorResponse(mtest.CommandError{ Message: "Transaction numbers", Code: 19, }) cmdErrCode20WrongMsg := mtest.CreateCommandErrorResponse(mtest.CommandError{ Message: "Not transaction numbers", Code: 20, }) testCases := []struct { name string errResponse bson.D expectUnsupportedMsg bool }{ {"write error code 20", writeErrorCode20, true}, {"write error code 20 wrong msg", writeErrorCode20WrongMsg, false}, {"write error code 19 right msg", writeErrorCode19, false}, {"command error code 20", cmdErrCode20, true}, {"command error code 20 wrong msg", cmdErrCode20WrongMsg, false}, {"command error code 19 right msg", cmdErrCode19, false}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { mt.ClearMockResponses() mt.AddMockResponses(tc.errResponse) sess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) defer sess.EndSession(context.Background()) _, err = mt.Coll.InsertOne(context.Background(), bson.D{{"x", 1}}) assert.NotNil(mt, err, "expected err but got nil") if tc.expectUnsupportedMsg { assert.Equal(mt, driver.ErrUnsupportedStorageEngine.Error(), err.Error(), "expected error %v, got %v", driver.ErrUnsupportedStorageEngine, err) return } assert.NotEqual(mt, driver.ErrUnsupportedStorageEngine.Error(), err.Error(), "got ErrUnsupportedStorageEngine but wanted different error") }) } }) testAppName := "foo" appNameClientOpts := options.Client(). SetAppName(testAppName) appNameMtOpts := mtest.NewOptions(). ClientType(mtest.Proxy). ClientOptions(appNameClientOpts). Topologies(mtest.Single) mt.RunOpts("app name is always sent", appNameMtOpts, func(mt mtest.T) { err := mt.Client.Ping(context.Background(), mtest.PrimaryRp) assert.Nil(mt, err, "Ping error: %v", err) msgPairs := mt.GetProxiedMessages() assert.True(mt, len(msgPairs) >= 2, "expected at least 2 events sent, got %v", len(msgPairs)) // First two messages should be connection handshakes: one for the heartbeat connection and the other for the // application connection. for idx, pair := range msgPairs[:2] { helloCommand := handshake.LegacyHello // Expect "hello" command name with API version. if os.Getenv("REQUIRE_API_VERSION") == "true" { helloCommand = "hello" } assert.Equal(mt, pair.CommandName, helloCommand, "expected command name %s at index %d, got %s", helloCommand, idx, pair.CommandName) sent := pair.Sent appNameVal, err := sent.Command.LookupErr("client", "application", "name") assert.Nil(mt, err, "expected command %s at index %d to contain app name", sent.Command, idx) appName := appNameVal.StringValue() assert.Equal(mt, testAppName, appName, "expected app name %v at index %d, got %v", testAppName, idx, appName) } }) // Test that direct connections work as expected. firstServerAddr := mtest.GlobalTopology().Description().Servers[0].Addr directConnectionOpts := options.Client(). ApplyURI(fmt.Sprintf("mongodb://%s", firstServerAddr)). SetReadPreference(readpref.Primary()). SetDirect(true) mtOpts := mtest.NewOptions(). ClientOptions(directConnectionOpts). CreateCollection(false). MinServerVersion("3.6"). // Minimum server version 3.6 to force OP_MSG. Topologies(mtest.ReplicaSet) // Read preference isn't sent to standalones so we can test on replica sets. mt.RunOpts("direct connection made", mtOpts, func(mt mtest.T) { _, err := mt.Coll.Find(context.Background(), bson.D{}) assert.Nil(mt, err, "Find error: %v", err) // When connected directly, the primary read preference should be overwritten to primaryPreferred. evt := mt.GetStartedEvent() assert.Equal(mt, "find", evt.CommandName, "expected 'find' event, got '%s'", evt.CommandName) // A direct connection will result in a single topology, and so // the default readPreference mode should be "primaryPrefered". modeVal, err := evt.Command.LookupErr("$readPreference", "mode") assert.Nil(mt, err, "expected command %s to include $readPreference", evt.Command) mode := modeVal.StringValue() assert.Equal(mt, mode, "primaryPreferred", "expected read preference mode primaryPreferred, got %v", mode) }) // Test that using a client with minPoolSize set doesn't cause a data race. mtOpts = mtest.NewOptions().ClientOptions(options.Client().SetMinPoolSize(5)) mt.RunOpts("minPoolSize", mtOpts, func(mt mtest.T) { err := mt.Client.Ping(context.Background(), readpref.Primary()) assert.Nil(t, err, "unexpected error calling Ping: %v", err) }) mt.Run("minimum RTT is monitored", func(mt mtest.T) { mt.Parallel() // Reset the client with a dialer that delays all network round trips by 300ms and set the // heartbeat interval to 100ms to reduce the time it takes to collect RTT samples. mt.ResetClient(options.Client(). SetDialer(newSlowConnDialer(slowConnDialerDelay)). SetHeartbeatInterval(reducedHeartbeatInterval)) // Assert that the minimum RTT is eventually >250ms. topo := getTopologyFromClient(mt.Client) assert.Soon(mt, func(ctx context.Context) { for { // Stop loop if callback has been canceled. select { case <-ctx.Done(): return default: } time.Sleep(100 time.Millisecond) // Wait for all of the server's minimum RTTs to be >250ms. done := true for _, desc := range topo.Description().Servers { server, err := topo.FindServer(desc) assert.Nil(mt, err, "FindServer error: %v", err) if server.RTTMonitor().Min() <= 250time.Millisecond { done = false } } if done { return } } }, 10time.Second) }) // Test that if the minimum RTT is greater than the remaining timeout for an operation, the // operation is not sent to the server and no connections are closed. mt.Run("minimum RTT used to prevent sending requests", func(mt mtest.T) { mt.Parallel() // Assert that we can call Ping with a 250ms timeout. ctx, cancel := context.WithTimeout(context.Background(), 250time.Millisecond) defer cancel() err := mt.Client.Ping(ctx, nil) assert.Nil(mt, err, "Ping error: %v", err) // Reset the client with a dialer that delays all network round trips by 300ms and set the // heartbeat interval to 100ms to reduce the time it takes to collect RTT samples. tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(options.Client(). SetPoolMonitor(tpm.PoolMonitor). SetDialer(newSlowConnDialer(slowConnDialerDelay)). SetHeartbeatInterval(reducedHeartbeatInterval)) // Assert that the minimum RTT is eventually >250ms. topo := getTopologyFromClient(mt.Client) assert.Soon(mt, func(ctx context.Context) { for { // Stop loop if callback has been canceled. select { case <-ctx.Done(): return default: } time.Sleep(100 * time.Millisecond) // Wait for all of the server's minimum RTTs to be >250ms. done := true for _, desc := range topo.Description().Servers { server, err := topo.FindServer(desc) assert.Nil(mt, err, "FindServer error: %v", err) if server.RTTMonitor().Min() <= 250time.Millisecond { done = false } } if done { return } } }, 10time.Second) // Once we've waited for the minimum RTT for the single server to be >250ms, run a bunch of // Ping operations with a timeout of 250ms and expect that they return errors. for i := 0; i < 10; i++ { ctx, cancel = context.WithTimeout(context.Background(), 250time.Millisecond) err := mt.Client.Ping(ctx, nil) cancel() assert.NotNil(mt, err, "expected Ping to return an error") } // Assert that the Ping timeouts result in no connections being closed. closed := len(tpm.Events(func(e event.PoolEvent) bool { return e.Type == event.ConnectionClosed })) assert.Equal(t, 0, closed, "expected no connections to be closed") }) mt.Run("RTT90 is monitored", func(mt mtest.T) { mt.Parallel() // Reset the client with a dialer that delays all network round trips by 300ms and set the // heartbeat interval to 100ms to reduce the time it takes to collect RTT samples. mt.ResetClient(options.Client(). SetDialer(newSlowConnDialer(slowConnDialerDelay)). SetHeartbeatInterval(reducedHeartbeatInterval)) // Assert that RTT90s are eventually >300ms. topo := getTopologyFromClient(mt.Client) assert.Soon(mt, func(ctx context.Context) { for { // Stop loop if callback has been canceled. select { case <-ctx.Done(): return default: } time.Sleep(100 time.Millisecond) // Wait for all of the server's RTT90s to be >300ms. done := true for _, desc := range topo.Description().Servers { server, err := topo.FindServer(desc) assert.Nil(mt, err, "FindServer error: %v", err) if server.RTTMonitor().P90() <= 300time.Millisecond { done = false } } if done { return } } }, 10time.Second) }) // Test that if Timeout is set and the RTT90 is greater than the remaining timeout for an operation, the // operation is not sent to the server, fails with a timeout error, and no connections are closed. mt.Run("RTT90 used to prevent sending requests", func(mt mtest.T) { mt.Parallel() // Assert that we can call Ping with a 250ms timeout. ctx, cancel := context.WithTimeout(context.Background(), 250time.Millisecond) defer cancel() err := mt.Client.Ping(ctx, nil) assert.Nil(mt, err, "Ping error: %v", err) // Reset the client with a dialer that delays all network round trips by 300ms, set the // heartbeat interval to 100ms to reduce the time it takes to collect RTT samples, and // set a Timeout of 0 (infinite) on the Client to ensure that RTT90 is used as a sending // threshold. tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(options.Client(). SetPoolMonitor(tpm.PoolMonitor). SetDialer(newSlowConnDialer(slowConnDialerDelay)). SetHeartbeatInterval(reducedHeartbeatInterval). SetTimeout(0)) // Assert that RTT90s are eventually >275ms. topo := getTopologyFromClient(mt.Client) assert.Soon(mt, func(ctx context.Context) { for { // Stop loop if callback has been canceled. select { case <-ctx.Done(): return default: } time.Sleep(100 * time.Millisecond) // Wait for all of the server's RTT90s to be >275ms. done := true for _, desc := range topo.Description().Servers { server, err := topo.FindServer(desc) assert.Nil(mt, err, "FindServer error: %v", err) if server.RTTMonitor().P90() <= 275time.Millisecond { done = false } } if done { return } } }, 10time.Second) // Once we've waited for the RTT90 for the servers to be >275ms, run 10 Ping operations // with a timeout of 275ms and expect that they return timeout errors. for i := 0; i < 10; i++ { ctx, cancel = context.WithTimeout(context.Background(), 275time.Millisecond) err := mt.Client.Ping(ctx, nil) cancel() assert.NotNil(mt, err, "expected Ping to return an error") assert.True(mt, mongo.IsTimeout(err), "expected a timeout error, got: %v", err) } // Assert that the Ping timeouts result in no connections being closed. closed := len(tpm.Events(func(e event.PoolEvent) bool { return e.Type == event.ConnectionClosed })) assert.Equal(t, 0, closed, "expected no connections to be closed") }) // Test that OP_MSG is used for authentication-related commands on 3.6+ (WV 6+). Do not test when API version is // set, as handshakes will always use OP_MSG. opMsgOpts := mtest.NewOptions().ClientType(mtest.Proxy).MinServerVersion("3.6").Auth(true).RequireAPIVersion(false) mt.RunOpts("OP_MSG used for authentication on 3.6+", opMsgOpts, func(mt mtest.T) { err := mt.Client.Ping(context.Background(), mtest.PrimaryRp) assert.Nil(mt, err, "Ping error: %v", err) msgPairs := mt.GetProxiedMessages() assert.True(mt, len(msgPairs) >= 3, "expected at least 3 events, got %v", len(msgPairs)) // The first message should be a connection handshake. pair := msgPairs[0] assert.Equal(mt, handshake.LegacyHello, pair.CommandName, "expected command name %s at index 0, got %s", handshake.LegacyHello, pair.CommandName) assert.Equal(mt, wiremessage.OpQuery, pair.Sent.OpCode, "expected 'OP_QUERY' OpCode in wire message, got %q", pair.Sent.OpCode.String()) // Look for a saslContinue in the remaining proxied messages and assert that it uses the OP_MSG OpCode, as wire // version is now known to be >= 6. var saslContinueFound bool for _, pair := range msgPairs[1:] { if pair.CommandName == "saslContinue" { saslContinueFound = true assert.Equal(mt, wiremessage.OpMsg, pair.Sent.OpCode, "expected 'OP_MSG' OpCode in wire message, got %s", pair.Sent.OpCode.String()) break } } assert.True(mt, saslContinueFound, "did not find 'saslContinue' command in proxied messages") }) // Test that OP_MSG is used for handshakes when API version is declared. opMsgSAPIOpts := mtest.NewOptions().ClientType(mtest.Proxy).MinServerVersion("5.0").RequireAPIVersion(true) mt.RunOpts("OP_MSG used for handshakes when API version declared", opMsgSAPIOpts, func(mt mtest.T) { err := mt.Client.Ping(context.Background(), mtest.PrimaryRp) assert.Nil(mt, err, "Ping error: %v", err) msgPairs := mt.GetProxiedMessages() assert.True(mt, len(msgPairs) >= 3, "expected at least 3 events, got %v", len(msgPairs)) // First three messages should be connection handshakes: one for the heartbeat connection, another for the // application connection, and a final one for the RTT monitor connection. for idx, pair := range msgPairs[:3] { assert.Equal(mt, "hello", pair.CommandName, "expected command name 'hello' at index %d, got %s", idx, pair.CommandName) // Assert that appended OpCode is OP_MSG when API version is set. assert.Equal(mt, wiremessage.OpMsg, pair.Sent.OpCode, "expected 'OP_MSG' OpCode in wire message, got %q", pair.Sent.OpCode.String()) } }) } func TestClient_BSONOptions(t testing.T) { t.Parallel() mt := mtest.New(t, noClientOpts) type jsonTagsTest struct { A string B string `json:"x"` C string `json:"y" bson:"3"` } testCases := []struct { name string bsonOpts options.BSONOptions doc interface{} decodeInto func() interface{} want interface{} wantRaw bson.Raw }{ { name: "UseJSONStructTags", bsonOpts: &options.BSONOptions{ UseJSONStructTags: true, }, doc: jsonTagsTest{ A: "apple", B: "banana", C: "carrot", }, decodeInto: func() interface{} { return &jsonTagsTest{} }, want: &jsonTagsTest{ A: "apple", B: "banana", C: "carrot", }, wantRaw: bson.Raw(bsoncore.NewDocumentBuilder(). AppendString("a", "apple"). AppendString("x", "banana"). AppendString("3", "carrot"). Build()), }, { name: "IntMinSize", bsonOpts: &options.BSONOptions{ IntMinSize: true, }, doc: bson.D{{Key: "x", Value: int64(1)}}, decodeInto: func() interface{} { return &bson.D{} }, want: &bson.D{{Key: "x", Value: int32(1)}}, wantRaw: bson.Raw(bsoncore.NewDocumentBuilder(). AppendInt32("x", 1). Build()), }, { name: "DefaultDocumentM", bsonOpts: &options.BSONOptions{ DefaultDocumentM: true, }, doc: bson.D{{Key: "doc", Value: bson.D{{Key: "a", Value: int64(1)}}}}, decodeInto: func() interface{} { return &bson.D{} }, want: &bson.D{{Key: "doc", Value: bson.M{"a": int64(1)}}}, }, } for _, tc := range testCases { opts := mtest.NewOptions().ClientOptions( options.Client().SetBSONOptions(tc.bsonOpts)) mt.RunOpts(tc.name, opts, func(mt mtest.T) { res, err := mt.Coll.InsertOne(context.Background(), tc.doc) require.NoError(mt, err, "InsertOne error") sr := mt.Coll.FindOne( context.Background(), bson.D{{Key: "_id", Value: res.InsertedID}}, // Exclude the auto-generated "_id" field so we can make simple // assertions on the return value. options.FindOne().SetProjection(bson.D{{Key: "_id", Value: 0}})) if tc.want != nil { got := tc.decodeInto() err := sr.Decode(got) require.NoError(mt, err, "Decode error") assert.Equal(mt, tc.want, got, "expected and actual decoded result are different") } if tc.wantRaw != nil { got, err := sr.Raw() require.NoError(mt, err, "Raw error") assert.EqualBSON(mt, tc.wantRaw, got) } }) } opts := mtest.NewOptions().ClientOptions( options.Client().SetBSONOptions(&options.BSONOptions{ ErrorOnInlineDuplicates: true, })) mt.RunOpts("ErrorOnInlineDuplicates", opts, func(mt mtest.T) { type inlineDupInner struct { A string } type inlineDupOuter struct { A string B inlineDupInner `bson:"b,inline"` } _, err := mt.Coll.InsertOne(context.Background(), inlineDupOuter{ A: "outer", B: &inlineDupInner{ A: "inner", }, }) require.Error(mt, err, "expected InsertOne to return an error") }) } func TestClientStress(t testing.T) { mtOpts := mtest.NewOptions().CreateClient(false) mt := mtest.New(t, mtOpts) // Test that a Client can recover from a massive traffic spike after the traffic spike is over. mt.Run("Client recovers from traffic spike", func(mt mtest.T) { oid := primitive.NewObjectID() doc := bson.D{{Key: "_id", Value: oid}, {Key: "key", Value: "value"}} _, err := mt.Coll.InsertOne(context.Background(), doc) assert.Nil(mt, err, "InsertOne error: %v", err) // findOne calls FindOne("_id": oid) on the given collection and with the given timeout. It // returns any errors. findOne := func(coll mongo.Collection, timeout time.Duration) error { ctx, cancel := context.WithTimeout(context.Background(), timeout) defer cancel() var res map[string]interface{} return coll.FindOne(ctx, bson.D{{Key: "_id", Value: oid}}).Decode(&res) } // findOneFor calls FindOne on the given collection and with the given timeout in a loop for // the given duration and returns any errors returned by FindOne. findOneFor := func(coll mongo.Collection, timeout time.Duration, d time.Duration) []error { errs := make([]error, 0) start := time.Now() for time.Since(start) <= d { err := findOne(coll, timeout) if err != nil { errs = append(errs, err) } time.Sleep(10 time.Microsecond) } return errs } // Calculate the maximum observed round-trip time by measuring the duration of some FindOne // operations and picking the max. var maxRTT time.Duration for i := 0; i < 50; i++ { start := time.Now() err := findOne(mt.Coll, 10time.Second) assert.Nil(t, err, "FindOne error: %v", err) duration := time.Since(start) if duration > maxRTT { maxRTT = duration } } assert.True(mt, maxRTT > 0, "RTT must be greater than 0") // Run tests with various "maxPoolSize" values, including 1-connection pools and the default // size of 100, to test how the client handles traffic spikes using different connection // pool configurations. maxPoolSizes := []uint64{1, 10, 100} for _, maxPoolSize := range maxPoolSizes { tpm := eventtest.NewTestPoolMonitor() maxPoolSizeOpt := mtest.NewOptions().ClientOptions( options.Client(). SetPoolMonitor(tpm.PoolMonitor). SetMaxPoolSize(maxPoolSize)) mt.RunOpts(fmt.Sprintf("maxPoolSize %d", maxPoolSize), maxPoolSizeOpt, func(mt mtest.T) { // Print the count of connection created, connection closed, and pool clear events // collected during the test to help with debugging. defer func() { created := len(tpm.Events(func(e event.PoolEvent) bool { return e.Type == event.ConnectionCreated })) closed := len(tpm.Events(func(e event.PoolEvent) bool { return e.Type == event.ConnectionClosed })) poolCleared := len(tpm.Events(func(e event.PoolEvent) bool { return e.Type == event.PoolCleared })) mt.Logf("Connections created: %d, connections closed: %d, pool clears: %d", created, closed, poolCleared) }() doc := bson.D{{Key: "_id", Value: oid}, {Key: "key", Value: "value"}} _, err := mt.Coll.InsertOne(context.Background(), doc) assert.Nil(mt, err, "InsertOne error: %v", err) // Set the timeout to be 100x the maximum observed RTT. Use a minimum 100ms timeout to // prevent spurious test failures due to extremely low timeouts. timeout := maxRTT 100 minTimeout := 100 * time.Millisecond if timeout < minTimeout { timeout = minTimeout } mt.Logf("Max RTT %v; using a timeout of %v", maxRTT, timeout) // Warm up the client for 1 second to allow connections to be established. Ignore // any errors. _ = findOneFor(mt.Coll, timeout, 1time.Second) // Simulate normal traffic by running one FindOne loop for 1 second and assert that there // are no errors. errs := findOneFor(mt.Coll, timeout, 1time.Second) assert.True(mt, len(errs) == 0, "expected no errors, but got %d (%v)", len(errs), errs) // Simulate an extreme traffic spike by running 1,000 FindOne loops in parallel for 10 // seconds and expect at least some errors to occur. g := new(errgroup.Group) for i := 0; i < 1000; i++ { g.Go(func() error { errs := findOneFor(mt.Coll, timeout, 10time.Second) if len(errs) == 0 { return nil } return errs[len(errs)-1] }) } err = g.Wait() mt.Logf("Error from extreme traffic spike (errors are expected): %v", err) // Simulate normal traffic again for 5 second. Ignore any errors to allow any outstanding // connection errors to stop. _ = findOneFor(mt.Coll, timeout, 5time.Second) // Simulate normal traffic again for 1 second and assert that there are no errors. errs = findOneFor(mt.Coll, timeout, 1*time.Second) assert.True(mt, len(errs) == 0, "expected no errors, but got %d (%v)", len(errs), errs) }) } }) }	35.04 KB	2025-05-25 12:27
📄 cmd_monitoring_helpers_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "bytes" "encoding/hex" "errors" "fmt" "strings" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) // Helper functions to compare BSON values and command monitoring expectations. func numberFromValue(mt mtest.T, val bson.RawValue) int64 { mt.Helper() switch val.Type { case bson.TypeInt32: return int64(val.Int32()) case bson.TypeInt64: return val.Int64() case bson.TypeDouble: return int64(val.Double()) default: mt.Fatalf("unexpected type for number: %v", val.Type) } return 0 } func compareNumberValues(mt mtest.T, key string, expected, actual bson.RawValue) error { eInt := numberFromValue(mt, expected) if eInt == 42 { if actual.Type == bson.TypeNull { return fmt.Errorf("expected non-null value for key %s, got null", key) } return nil } aInt := numberFromValue(mt, actual) if eInt != aInt { return fmt.Errorf("value mismatch for key %s; expected %s, got %s", key, expected, actual) } return nil } // compare BSON values and fail if they are not equal. the key parameter is used for error strings. // if the expected value is a numeric type (int32, int64, or double) and the value is 42, the function only asserts that // the actual value is non-null. func compareValues(mt mtest.T, key string, expected, actual bson.RawValue) error { mt.Helper() switch expected.Type { case bson.TypeInt32, bson.TypeInt64, bson.TypeDouble: if err := compareNumberValues(mt, key, expected, actual); err != nil { return err } return nil case bson.TypeString: val := expected.StringValue() if val == "42" { if actual.Type == bson.TypeNull { return fmt.Errorf("expected non-null value for key %s, got null", key) } return nil } // Don't return. Compare bytes for expected.Value and actual.Value outside of the switch. case bson.TypeEmbeddedDocument: e := expected.Document() if typeVal, err := e.LookupErr("$$type"); err == nil { // $$type represents a type assertion // for example {field: {$$type: "binData"}} should assert that "field" is an element with a binary value return checkValueType(mt, key, actual.Type, typeVal.StringValue()) } a := actual.Document() return compareDocsHelper(mt, e, a, key) case bson.TypeArray: e := expected.Array() a := actual.Array() return compareDocsHelper(mt, e, a, key) } if expected.Type != actual.Type { return fmt.Errorf("type mismatch for key %s; expected %s, got %s", key, expected.Type, actual.Type) } if !bytes.Equal(expected.Value, actual.Value) { return fmt.Errorf( "value mismatch for key %s; expected %s (hex=%s), got %s (hex=%s)", key, expected.Value, hex.EncodeToString(expected.Value), actual.Value, hex.EncodeToString(actual.Value)) } return nil } // helper for $$type assertions func checkValueType(mt mtest.T, key string, actual bsontype.Type, typeStr string) error { mt.Helper() var expected bsontype.Type switch typeStr { case "double": expected = bsontype.Double case "string": expected = bsontype.String case "object": expected = bsontype.EmbeddedDocument case "array": expected = bsontype.Array case "binData": expected = bsontype.Binary case "undefined": expected = bsontype.Undefined case "objectId": expected = bsontype.ObjectID case "boolean": expected = bsontype.Boolean case "date": expected = bsontype.DateTime case "null": expected = bsontype.Null case "regex": expected = bsontype.Regex case "dbPointer": expected = bsontype.DBPointer case "javascript": expected = bsontype.JavaScript case "symbol": expected = bsontype.Symbol case "javascriptWithScope": expected = bsontype.CodeWithScope case "int": expected = bsontype.Int32 case "timestamp": expected = bsontype.Timestamp case "long": expected = bsontype.Int64 case "decimal": expected = bsontype.Decimal128 case "minKey": expected = bsontype.MinKey case "maxKey": expected = bsontype.MaxKey default: mt.Fatalf("unrecognized type string: %v", typeStr) } if expected != actual { return fmt.Errorf("BSON type mismatch for key %s; expected %s, got %s", key, expected, actual) } return nil } // compare expected and actual BSON documents. comparison succeeds if actual contains each element in expected. func compareDocsHelper(mt mtest.T, expected, actual bson.Raw, prefix string) error { mt.Helper() eElems, err := expected.Elements() assert.Nil(mt, err, "error getting expected elements: %v", err) for _, e := range eElems { eKey := e.Key() fullKeyName := eKey if prefix != "" { fullKeyName = prefix + "." + eKey } aVal, err := actual.LookupErr(eKey) if e.Value().Type == bson.TypeNull { // Expected value is BSON null. Expect the actual field to be omitted. if errors.Is(err, bsoncore.ErrElementNotFound) { continue } if err != nil { return fmt.Errorf("expected key %q to be omitted but got error: %w", eKey, err) } return fmt.Errorf("expected key %q to be omitted but got %q", eKey, aVal) } if err != nil { return fmt.Errorf("key %s not found in result", fullKeyName) } if err := compareValues(mt, fullKeyName, e.Value(), aVal); err != nil { return err } } return nil } func compareDocs(mt mtest.T, expected, actual bson.Raw) error { mt.Helper() return compareDocsHelper(mt, expected, actual, "") } func checkExpectations(mt mtest.T, expectations []expectation, id0, id1 bson.Raw) { mt.Helper() // If the expectations field in the test JSON is null, we want to skip all command monitoring assertions. if expectations == nil { return } // Filter out events that shouldn't show up in monitoring expectations. ignoredEvents := map[string]struct{}{ "configureFailPoint": {}, } mt.FilterStartedEvents(func(evt event.CommandStartedEvent) bool { // ok is true if the command should be ignored, so return !ok _, ok := ignoredEvents[evt.CommandName] return !ok }) mt.FilterSucceededEvents(func(evt event.CommandSucceededEvent) bool { // ok is true if the command should be ignored, so return !ok _, ok := ignoredEvents[evt.CommandName] return !ok }) mt.FilterFailedEvents(func(evt event.CommandFailedEvent) bool { // ok is true if the command should be ignored, so return !ok _, ok := ignoredEvents[evt.CommandName] return !ok }) // If the expectations field in the test JSON is non-null but is empty, we want to assert that no events were // emitted. if len(expectations) == 0 { // One of the bulkWrite spec tests expects update and updateMany to be grouped together into a single batch, // but this isn't the case because of GODRIVER-1157. To work around this, we expect one event to be emitted for // that test rather than 0. This assertion should be changed when GODRIVER-1157 is done. numExpectedEvents := 0 bulkWriteTestName := "BulkWrite_on_server_that_doesn't_support_arrayFilters_with_arrayFilters_on_second_op" if strings.HasSuffix(mt.Name(), bulkWriteTestName) { numExpectedEvents = 1 } numActualEvents := len(mt.GetAllStartedEvents()) assert.Equal(mt, numExpectedEvents, numActualEvents, "expected %d events to be sent, but got %d events", numExpectedEvents, numActualEvents) return } for idx, expectation := range expectations { var err error if expectation.CommandStartedEvent != nil { err = compareStartedEvent(mt, expectation, id0, id1) } if expectation.CommandSucceededEvent != nil { err = compareSucceededEvent(mt, expectation) } if expectation.CommandFailedEvent != nil { err = compareFailedEvent(mt, expectation) } assert.Nil(mt, err, "expectation comparison error at index %v: %s", idx, err) } } // newMatchError appends `expected` and `actual` BSON data to an error. func newMatchError(mt mtest.T, expected bson.Raw, actual bson.Raw, format string, args ...interface{}) error { mt.Helper() msg := fmt.Sprintf(format, args...) expectedJSON, err := bson.MarshalExtJSON(expected, true, false) assert.Nil(mt, err, "error in MarshalExtJSON: %v", err) actualJSON, err := bson.MarshalExtJSON(actual, true, false) assert.Nil(mt, err, "error in MarshalExtJSON: %v", err) return fmt.Errorf("%s\nExpected %s\nGot: %s", msg, string(expectedJSON), string(actualJSON)) } func compareStartedEvent(mt mtest.T, expectation expectation, id0, id1 bson.Raw) error { mt.Helper() expected := expectation.CommandStartedEvent if len(expected.Extra) > 0 { return fmt.Errorf("unrecognized fields for CommandStartedEvent: %v", expected.Extra) } evt := mt.GetStartedEvent() if evt == nil { return errors.New("expected CommandStartedEvent, got nil") } if expected.CommandName != "" && expected.CommandName != evt.CommandName { return fmt.Errorf("command name mismatch; expected %s, got %s", expected.CommandName, evt.CommandName) } if expected.DatabaseName != "" && expected.DatabaseName != evt.DatabaseName { return fmt.Errorf("database name mismatch; expected %s, got %s", expected.DatabaseName, evt.DatabaseName) } eElems, err := expected.Command.Elements() if err != nil { return fmt.Errorf("error getting expected command elements: %s", err) } for _, elem := range eElems { key := elem.Key() val := elem.Value() actualVal, err := evt.Command.LookupErr(key) // Keys that may be nil if val.Type == bson.TypeNull { // Expected value is BSON null. Expect the actual field to be omitted. if errors.Is(err, bsoncore.ErrElementNotFound) { continue } if err != nil { return newMatchError(mt, expected.Command, evt.Command, "expected key %q to be omitted but got error: %v", key, err) } return newMatchError(mt, expected.Command, evt.Command, "expected key %q to be omitted but got %q", key, actualVal) } assert.Nil(mt, err, "expected command to contain key %q", key) if key == "batchSize" { // Some command monitoring tests expect that the driver will send a lower batch size if the required batch // size is lower than the operation limit. We only do this for legacy servers <= 3.0 because those server // versions do not support the limit option, but not for 3.2+. We've already validated that the command // contains a batchSize field above and we can skip the actual value comparison below. continue } switch key { case "lsid": sessName := val.StringValue() var expectedID bson.Raw actualID := actualVal.Document() switch sessName { case "session0": expectedID = id0 case "session1": expectedID = id1 default: return newMatchError(mt, expected.Command, evt.Command, "unrecognized session identifier in command document: %s", sessName) } if !bytes.Equal(expectedID, actualID) { return newMatchError(mt, expected.Command, evt.Command, "session ID mismatch for session %s; expected %s, got %s", sessName, expectedID, actualID) } default: if err := compareValues(mt, key, val, actualVal); err != nil { return newMatchError(mt, expected.Command, evt.Command, "%s", err) } } } return nil } func compareWriteErrors(mt mtest.T, expected, actual bson.Raw) error { mt.Helper() expectedErrors, _ := expected.Values() actualErrors, _ := actual.Values() for i, expectedErrVal := range expectedErrors { expectedErr := expectedErrVal.Document() actualErr := actualErrors[i].Document() eIdx := expectedErr.Lookup("index").Int32() aIdx := actualErr.Lookup("index").Int32() if eIdx != aIdx { return fmt.Errorf("write error index mismatch at index %d; expected %d, got %d", i, eIdx, aIdx) } eCode := expectedErr.Lookup("code").Int32() aCode := actualErr.Lookup("code").Int32() if eCode != 42 && eCode != aCode { return fmt.Errorf("write error code mismatch at index %d; expected %d, got %d", i, eCode, aCode) } eMsg := expectedErr.Lookup("errmsg").StringValue() aMsg := actualErr.Lookup("errmsg").StringValue() if eMsg == "" { if aMsg == "" { return fmt.Errorf("write error message mismatch at index %d; expected non-empty message, got empty", i) } return nil } if eMsg != aMsg { return fmt.Errorf("write error message mismatch at index %d, expected %s, got %s", i, eMsg, aMsg) } } return nil } func compareSucceededEvent(mt mtest.T, expectation expectation) error { mt.Helper() expected := expectation.CommandSucceededEvent if len(expected.Extra) > 0 { return fmt.Errorf("unrecognized fields for CommandSucceededEvent: %v", expected.Extra) } evt := mt.GetSucceededEvent() if evt == nil { return errors.New("expected CommandSucceededEvent, got nil") } if expected.CommandName != "" && expected.CommandName != evt.CommandName { return fmt.Errorf("command name mismatch; expected %s, got %s", expected.CommandName, evt.CommandName) } eElems, err := expected.Reply.Elements() if err != nil { return fmt.Errorf("error getting expected reply elements: %s", err) } for _, elem := range eElems { key := elem.Key() val := elem.Value() actualVal := evt.Reply.Lookup(key) switch key { case "writeErrors": if err = compareWriteErrors(mt, val.Array(), actualVal.Array()); err != nil { return newMatchError(mt, expected.Reply, evt.Reply, "%s", err) } default: if err := compareValues(mt, key, val, actualVal); err != nil { return newMatchError(mt, expected.Reply, evt.Reply, "%s", err) } } } return nil } func compareFailedEvent(mt mtest.T, expectation expectation) error { mt.Helper() expected := expectation.CommandFailedEvent if len(expected.Extra) > 0 { return fmt.Errorf("unrecognized fields for CommandFailedEvent: %v", expected.Extra) } evt := mt.GetFailedEvent() if evt == nil { return errors.New("expected CommandFailedEvent, got nil") } if expected.CommandName != "" && expected.CommandName != evt.CommandName { return fmt.Errorf("command name mismatch; expected %s, got %s", expected.CommandName, evt.CommandName) } return nil }	14.02 KB	2025-05-25 12:27
📄 collection_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "errors" "strings" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/mongo/writeconcern" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) const ( errorDuplicateKey = 11000 errorCappedCollDeleteLegacy = 10101 errorCappedCollDelete = 20 errorModifiedIDLegacy = 16837 errorModifiedID = 66 ) var ( // impossibleWc is a write concern that can't be satisfied and is used to test write concern errors // for various operations. It includes a timeout because legacy servers will wait for all W nodes to respond, // causing tests to hang. impossibleWc = writeconcern.New(writeconcern.W(30), writeconcern.WTimeout(time.Second)) ) func TestCollection(t testing.T) { mt := mtest.New(t, mtest.NewOptions().CreateClient(false)) mt.RunOpts("insert one", noClientOpts, func(mt mtest.T) { mt.Run("success", func(mt mtest.T) { id := primitive.NewObjectID() doc := bson.D{{"_id", id}, {"x", 1}} res, err := mt.Coll.InsertOne(context.Background(), doc) assert.Nil(mt, err, "InsertOne error: %v", err) assert.Equal(mt, id, res.InsertedID, "expected inserted ID %v, got %v", id, res.InsertedID) }) mt.Run("write error", func(mt mtest.T) { doc := bson.D{{"_id", 1}} _, err := mt.Coll.InsertOne(context.Background(), doc) assert.Nil(mt, err, "InsertOne error: %v", err) _, err = mt.Coll.InsertOne(context.Background(), doc) we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error type %T, got %T", mongo.WriteException{}, err) assert.Equal(mt, 1, len(we.WriteErrors), "expected 1 write error, got %v", len(we.WriteErrors)) writeErr := we.WriteErrors[0] assert.Equal(mt, errorDuplicateKey, writeErr.Code, "expected code %v, got %v", errorDuplicateKey, writeErr.Code) }) wcCollOpts := options.Collection().SetWriteConcern(impossibleWc) wcTestOpts := mtest.NewOptions().CollectionOptions(wcCollOpts).Topologies(mtest.ReplicaSet) mt.RunOpts("write concern error", wcTestOpts, func(mt mtest.T) { doc := bson.D{{"_id", 1}} _, err := mt.Coll.InsertOne(context.Background(), doc) we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.WriteException{}, err) assert.NotNil(mt, we.WriteConcernError, "expected write concern error, got %+v", we) }) // Require 3.2 servers for bypassDocumentValidation support. convertedOptsOpts := mtest.NewOptions().MinServerVersion("3.2") mt.RunOpts("options are converted", convertedOptsOpts, func(mt mtest.T) { nilOptsTestCases := []struct { name string opts []options.InsertOneOptions expectOptionSet bool }{ { "only nil is passed", []options.InsertOneOptions{nil}, false, }, { "non-nil options is passed before nil", []options.InsertOneOptions{options.InsertOne().SetBypassDocumentValidation(true), nil}, true, }, { "non-nil options is passed after nil", []options.InsertOneOptions{nil, options.InsertOne().SetBypassDocumentValidation(true)}, true, }, } for _, testCase := range nilOptsTestCases { mt.Run(testCase.name, func(mt mtest.T) { doc := bson.D{{"x", 1}} _, err := mt.Coll.InsertOne(context.Background(), doc, testCase.opts...) assert.Nil(mt, err, "InsertOne error: %v", err) optName := "bypassDocumentValidation" evt := mt.GetStartedEvent() val, err := evt.Command.LookupErr(optName) if testCase.expectOptionSet { assert.Nil(mt, err, "expected %v to be set but got: %v", optName, err) assert.True(mt, val.Boolean(), "expected %v to be true but got: %v", optName, val.Boolean()) return } assert.NotNil(mt, err, "expected %v to be unset but got nil", optName) }) } }) }) mt.RunOpts("insert many", noClientOpts, func(mt mtest.T) { mt.Parallel() mt.Run("success", func(mt mtest.T) { mt.Parallel() want1 := int32(11) want2 := int32(12) docs := []interface{}{ bson.D{{"_id", want1}}, bson.D{{"x", 6}}, bson.D{{"_id", want2}}, } res, err := mt.Coll.InsertMany(context.Background(), docs) assert.Nil(mt, err, "InsertMany error: %v", err) assert.Equal(mt, 3, len(res.InsertedIDs), "expected 3 inserted IDs, got %v", len(res.InsertedIDs)) assert.Equal(mt, want1, res.InsertedIDs[0], "expected inserted ID %v, got %v", want1, res.InsertedIDs[0]) assert.NotNil(mt, res.InsertedIDs[1], "expected ID but got nil") assert.Equal(mt, want2, res.InsertedIDs[2], "expected inserted ID %v, got %v", want2, res.InsertedIDs[2]) }) mt.Run("batches", func(mt mtest.T) { mt.Parallel() const ( megabyte = 10 * 10 * 10 * 10 * 10 * 10 numDocs = 700000 ) var docs []interface{} total := uint32(0) expectedDocSize := uint32(26) for i := 0; i < numDocs; i++ { d := bson.D{ {"a", int32(i)}, {"b", int32(i * 2)}, {"c", int32(i * 3)}, } b, _ := bson.Marshal(d) assert.Equal(mt, int(expectedDocSize), len(b), "expected doc len %v, got %v", expectedDocSize, len(b)) docs = append(docs, d) total += uint32(len(b)) } assert.True(mt, total > 16megabyte, "expected total greater than 16mb but got %v", total) res, err := mt.Coll.InsertMany(context.Background(), docs) assert.Nil(mt, err, "InsertMany error: %v", err) assert.Equal(mt, numDocs, len(res.InsertedIDs), "expected %v inserted IDs, got %v", numDocs, len(res.InsertedIDs)) }) mt.Run("large document batches", func(mt mtest.T) { mt.Parallel() docs := []interface{}{create16MBDocument(mt), create16MBDocument(mt)} _, err := mt.Coll.InsertMany(context.Background(), docs) assert.Nil(mt, err, "InsertMany error: %v", err) evt := mt.GetStartedEvent() assert.Equal(mt, "insert", evt.CommandName, "expected 'insert' event, got '%v'", evt.CommandName) evt = mt.GetStartedEvent() assert.Equal(mt, "insert", evt.CommandName, "expected 'insert' event, got '%v'", evt.CommandName) }) mt.RunOpts("write error", noClientOpts, func(mt mtest.T) { mt.Parallel() docs := []interface{}{ bson.D{{"_id", primitive.NewObjectID()}}, bson.D{{"_id", primitive.NewObjectID()}}, bson.D{{"_id", primitive.NewObjectID()}}, } testCases := []struct { name string ordered bool numErrors int }{ {"unordered", false, 3}, {"ordered", true, 1}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { _, err := mt.Coll.InsertMany(context.Background(), docs) assert.Nil(mt, err, "InsertMany error: %v", err) _, err = mt.Coll.InsertMany(context.Background(), docs, options.InsertMany().SetOrdered(tc.ordered)) we, ok := err.(mongo.BulkWriteException) assert.True(mt, ok, "expected error type %T, got %T", mongo.BulkWriteException{}, err) numErrors := len(we.WriteErrors) assert.Equal(mt, tc.numErrors, numErrors, "expected %v write errors, got %v", tc.numErrors, numErrors) gotCode := we.WriteErrors[0].Code assert.Equal(mt, errorDuplicateKey, gotCode, "expected error code %v, got %v", errorDuplicateKey, gotCode) }) } }) mt.Run("return only inserted ids", func(mt mtest.T) { mt.Parallel() id := int32(15) docs := []interface{}{ bson.D{{"_id", id}}, bson.D{{"_id", id}}, bson.D{{"x", 6}}, bson.D{{"_id", id}}, } testCases := []struct { name string ordered bool numInserted int numErrors int }{ {"unordered", false, 2, 2}, {"ordered", true, 1, 1}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { res, err := mt.Coll.InsertMany(context.Background(), docs, options.InsertMany().SetOrdered(tc.ordered)) assert.Equal(mt, tc.numInserted, len(res.InsertedIDs), "expected %v inserted IDs, got %v", tc.numInserted, len(res.InsertedIDs)) assert.Equal(mt, id, res.InsertedIDs[0], "expected inserted ID %v, got %v", id, res.InsertedIDs[0]) if tc.numInserted > 1 { assert.NotNil(mt, res.InsertedIDs[1], "expected ID but got nil") } we, ok := err.(mongo.BulkWriteException) assert.True(mt, ok, "expected error type %T, got %T", mongo.BulkWriteException{}, err) numErrors := len(we.WriteErrors) assert.Equal(mt, tc.numErrors, numErrors, "expected %v write errors, got %v", tc.numErrors, numErrors) gotCode := we.WriteErrors[0].Code assert.Equal(mt, errorDuplicateKey, gotCode, "expected error code %v, got %v", errorDuplicateKey, gotCode) }) } }) mt.Run("writeError index", func(mt mtest.T) { mt.Parallel() // force multiple batches numDocs := 700000 var docs []interface{} for i := 0; i < numDocs; i++ { d := bson.D{ {"a", int32(i)}, {"b", int32(i 2)}, {"c", int32(i * 3)}, } docs = append(docs, d) } repeated := bson.D{{"_id", int32(11)}} docs = append(docs, repeated, repeated) _, err := mt.Coll.InsertMany(context.Background(), docs) assert.NotNil(mt, err, "expected InsertMany error, got nil") we, ok := err.(mongo.BulkWriteException) assert.True(mt, ok, "expected error type %T, got %T", mongo.BulkWriteException{}, err) numErrors := len(we.WriteErrors) assert.Equal(mt, 1, numErrors, "expected 1 write error, got %v", numErrors) gotIndex := we.WriteErrors[0].Index assert.Equal(mt, numDocs+1, gotIndex, "expected index %v, got %v", numDocs+1, gotIndex) }) wcCollOpts := options.Collection().SetWriteConcern(impossibleWc) wcTestOpts := mtest.NewOptions().CollectionOptions(wcCollOpts).Topologies(mtest.ReplicaSet) mt.RunOpts("write concern error", wcTestOpts, func(mt mtest.T) { _, err := mt.Coll.InsertMany(context.Background(), []interface{}{bson.D{{"_id", 1}}}) we, ok := err.(mongo.BulkWriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.BulkWriteException{}, err) assert.NotNil(mt, we.WriteConcernError, "expected write concern error, got %+v", err) }) }) mt.RunOpts("delete one", noClientOpts, func(mt mtest.T) { mt.Run("found", func(mt mtest.T) { initCollection(mt, mt.Coll) res, err := mt.Coll.DeleteOne(context.Background(), bson.D{{"x", 1}}) assert.Nil(mt, err, "DeleteOne error: %v", err) assert.Equal(mt, int64(1), res.DeletedCount, "expected DeletedCount 1, got %v", res.DeletedCount) }) mt.Run("not found", func(mt mtest.T) { initCollection(mt, mt.Coll) res, err := mt.Coll.DeleteOne(context.Background(), bson.D{{"x", 0}}) assert.Nil(mt, err, "DeleteOne error: %v", err) assert.Equal(mt, int64(0), res.DeletedCount, "expected DeletedCount 0, got %v", res.DeletedCount) }) mt.RunOpts("not found with options", mtest.NewOptions().MinServerVersion("3.4"), func(mt mtest.T) { initCollection(mt, mt.Coll) opts := options.Delete().SetCollation(&options.Collation{Locale: "en_US"}) res, err := mt.Coll.DeleteOne(context.Background(), bson.D{{"x", 0}}, opts) assert.Nil(mt, err, "DeleteOne error: %v", err) assert.Equal(mt, int64(0), res.DeletedCount, "expected DeletedCount 0, got %v", res.DeletedCount) }) mt.RunOpts("write error", mtest.NewOptions().MaxServerVersion("5.0.7"), func(mt mtest.T) { // Deletes are not allowed on capped collections on MongoDB 5.0.6-. We use this // behavior to test the processing of write errors. cappedOpts := options.CreateCollection().SetCapped(true).SetSizeInBytes(64 * 1024) capped := mt.CreateCollection(mtest.Collection{ Name: "deleteOne_capped", CreateOpts: cappedOpts, }, true) _, err := capped.DeleteOne(context.Background(), bson.D{{"x", 1}}) we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error type %T, got %T", mongo.WriteException{}, err) numWriteErrors := len(we.WriteErrors) assert.Equal(mt, 1, numWriteErrors, "expected 1 write error, got %v", numWriteErrors) gotCode := we.WriteErrors[0].Code assert.True(mt, gotCode == errorCappedCollDeleteLegacy \|\| gotCode == errorCappedCollDelete, "expected error code %v or %v, got %v", errorCappedCollDeleteLegacy, errorCappedCollDelete, gotCode) }) mt.RunOpts("write concern error", mtest.NewOptions().Topologies(mtest.ReplicaSet), func(mt mtest.T) { // 2.6 returns right away if the document doesn't exist filter := bson.D{{"x", 1}} _, err := mt.Coll.InsertOne(context.Background(), filter) assert.Nil(mt, err, "InsertOne error: %v", err) mt.CloneCollection(options.Collection().SetWriteConcern(impossibleWc)) _, err = mt.Coll.DeleteOne(context.Background(), filter) we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error type %T, got %T", mongo.WriteException{}, err) assert.NotNil(mt, we.WriteConcernError, "expected write concern error, got nil") }) mt.RunOpts("single key map index", mtest.NewOptions().MinServerVersion("4.4"), func(mt mtest.T) { initCollection(mt, mt.Coll) indexView := mt.Coll.Indexes() _, err := indexView.CreateOne(context.Background(), mongo.IndexModel{ Keys: bson.D{{"x", 1}}, }) assert.Nil(mt, err, "CreateOne error: %v", err) opts := options.Delete().SetHint(bson.M{"x": 1}) res, err := mt.Coll.DeleteOne(context.Background(), bson.D{{"x", 1}}, opts) assert.Nil(mt, err, "DeleteOne error: %v", err) assert.Equal(mt, int64(1), res.DeletedCount, "expected DeletedCount 1, got %v", res.DeletedCount) }) mt.RunOpts("multikey map index", mtest.NewOptions().MinServerVersion("4.4"), func(mt mtest.T) { opts := options.Delete().SetHint(bson.M{"x": 1, "y": 1}) _, err := mt.Coll.DeleteOne(context.Background(), bson.D{{"x", 0}}, opts) assert.Equal(mt, mongo.ErrMapForOrderedArgument{"hint"}, err, "expected error %v, got %v", mongo.ErrMapForOrderedArgument{"hint"}, err) }) }) mt.RunOpts("delete many", noClientOpts, func(mt mtest.T) { mt.Run("found", func(mt mtest.T) { initCollection(mt, mt.Coll) res, err := mt.Coll.DeleteMany(context.Background(), bson.D{{"x", bson.D{{"$gte", 3}}}}) assert.Nil(mt, err, "DeleteMany error: %v", err) assert.Equal(mt, int64(3), res.DeletedCount, "expected DeletedCount 3, got %v", res.DeletedCount) }) mt.Run("not found", func(mt mtest.T) { initCollection(mt, mt.Coll) res, err := mt.Coll.DeleteMany(context.Background(), bson.D{{"x", bson.D{{"$lt", 1}}}}) assert.Nil(mt, err, "DeleteMany error: %v", err) assert.Equal(mt, int64(0), res.DeletedCount, "expected DeletedCount 0, got %v", res.DeletedCount) }) mt.RunOpts("not found with options", mtest.NewOptions().MinServerVersion("3.4"), func(mt mtest.T) { initCollection(mt, mt.Coll) opts := options.Delete().SetCollation(&options.Collation{Locale: "en_US"}) res, err := mt.Coll.DeleteMany(context.Background(), bson.D{{"x", bson.D{{"$lt", 1}}}}, opts) assert.Nil(mt, err, "DeleteMany error: %v", err) assert.Equal(mt, int64(0), res.DeletedCount, "expected DeletedCount 0, got %v", res.DeletedCount) }) mt.RunOpts("write error", mtest.NewOptions().MaxServerVersion("5.0.7"), func(mt mtest.T) { // Deletes are not allowed on capped collections on MongoDB 5.0.6-. We use this // behavior to test the processing of write errors. cappedOpts := options.CreateCollection().SetCapped(true).SetSizeInBytes(64 * 1024) capped := mt.CreateCollection(mtest.Collection{ Name: "deleteMany_capped", CreateOpts: cappedOpts, }, true) _, err := capped.DeleteMany(context.Background(), bson.D{{"x", 1}}) we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.WriteException{}, err) numWriteErrors := len(we.WriteErrors) assert.Equal(mt, 1, len(we.WriteErrors), "expected 1 write error, got %v", numWriteErrors) gotCode := we.WriteErrors[0].Code assert.True(mt, gotCode == errorCappedCollDeleteLegacy \|\| gotCode == errorCappedCollDelete, "expected error code %v or %v, got %v", errorCappedCollDeleteLegacy, errorCappedCollDelete, gotCode) }) mt.RunOpts("write concern error", mtest.NewOptions().Topologies(mtest.ReplicaSet), func(mt mtest.T) { // 2.6 server returns right away if the document doesn't exist filter := bson.D{{"x", 1}} _, err := mt.Coll.InsertOne(context.Background(), filter) assert.Nil(mt, err, "InsertOne error: %v", err) mt.CloneCollection(options.Collection().SetWriteConcern(impossibleWc)) _, err = mt.Coll.DeleteMany(context.Background(), filter) we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.WriteException{}, err) assert.NotNil(mt, we.WriteConcernError, "expected write concern error, got %+v", err) }) mt.RunOpts("single key map index", mtest.NewOptions().MinServerVersion("4.4"), func(mt mtest.T) { initCollection(mt, mt.Coll) indexView := mt.Coll.Indexes() _, err := indexView.CreateOne(context.Background(), mongo.IndexModel{ Keys: bson.D{{"x", 1}}, }) assert.Nil(mt, err, "index CreateOne error: %v", err) opts := options.Delete().SetHint(bson.M{"x": 1}) res, err := mt.Coll.DeleteOne(context.Background(), bson.D{{"x", 1}}, opts) assert.Nil(mt, err, "DeleteOne error: %v", err) assert.Equal(mt, int64(1), res.DeletedCount, "expected DeletedCount 1, got %v", res.DeletedCount) }) mt.RunOpts("multikey map index", mtest.NewOptions().MinServerVersion("4.4"), func(mt mtest.T) { opts := options.Delete().SetHint(bson.M{"x": 1, "y": 1}) _, err := mt.Coll.DeleteMany(context.Background(), bson.D{{"x", 0}}, opts) assert.Equal(mt, mongo.ErrMapForOrderedArgument{"hint"}, err, "expected error %v, got %v", mongo.ErrMapForOrderedArgument{"hint"}, err) }) }) mt.RunOpts("update one", noClientOpts, func(mt mtest.T) { mt.Run("empty update", func(mt mtest.T) { _, err := mt.Coll.UpdateOne(context.Background(), bson.D{}, bson.D{}) assert.NotNil(mt, err, "expected error, got nil") }) mt.Run("found", func(mt mtest.T) { initCollection(mt, mt.Coll) filter := bson.D{{"x", 1}} update := bson.D{{"$inc", bson.D{{"x", 1}}}} res, err := mt.Coll.UpdateOne(context.Background(), filter, update) assert.Nil(mt, err, "UpdateOne error: %v", err) assert.Equal(mt, int64(1), res.MatchedCount, "expected matched count 1, got %v", res.MatchedCount) assert.Equal(mt, int64(1), res.ModifiedCount, "expected matched count 1, got %v", res.ModifiedCount) assert.Nil(mt, res.UpsertedID, "expected upserted ID nil, got %v", res.UpsertedID) }) mt.Run("not found", func(mt mtest.T) { initCollection(mt, mt.Coll) filter := bson.D{{"x", 0}} update := bson.D{{"$inc", bson.D{{"x", 1}}}} res, err := mt.Coll.UpdateOne(context.Background(), filter, update) assert.Nil(mt, err, "UpdateOne error: %v", err) assert.Equal(mt, int64(0), res.MatchedCount, "expected matched count 0, got %v", res.MatchedCount) assert.Equal(mt, int64(0), res.ModifiedCount, "expected matched count 0, got %v", res.ModifiedCount) assert.Nil(mt, res.UpsertedID, "expected upserted ID nil, got %v", res.UpsertedID) }) mt.Run("upsert", func(mt mtest.T) { initCollection(mt, mt.Coll) filter := bson.D{{"x", 0}} update := bson.D{{"$inc", bson.D{{"x", 1}}}} res, err := mt.Coll.UpdateOne(context.Background(), filter, update, options.Update().SetUpsert(true)) assert.Nil(mt, err, "UpdateOne error: %v", err) assert.Equal(mt, int64(0), res.MatchedCount, "expected matched count 0, got %v", res.MatchedCount) assert.Equal(mt, int64(0), res.ModifiedCount, "expected matched count 0, got %v", res.ModifiedCount) assert.NotNil(mt, res.UpsertedID, "expected upserted ID, got nil") }) mt.Run("write error", func(mt mtest.T) { filter := bson.D{{"_id", "foo"}} update := bson.D{{"$set", bson.D{{"_id", 3.14159}}}} _, err := mt.Coll.InsertOne(context.Background(), filter) assert.Nil(mt, err, "InsertOne error: %v", err) _, err = mt.Coll.UpdateOne(context.Background(), filter, update) we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.WriteException{}, err) numWriteErrors := len(we.WriteErrors) assert.Equal(mt, 1, numWriteErrors, "expected 1 write error, got %v", numWriteErrors) gotCode := we.WriteErrors[0].Code assert.Equal(mt, errorModifiedID, gotCode, "expected error code %v, got %v", errorModifiedID, gotCode) }) mt.RunOpts("write concern error", mtest.NewOptions().Topologies(mtest.ReplicaSet), func(mt mtest.T) { // 2.6 returns right away if the document doesn't exist filter := bson.D{{"_id", "foo"}} update := bson.D{{"$set", bson.D{{"pi", 3.14159}}}} _, err := mt.Coll.InsertOne(context.Background(), filter) assert.Nil(mt, err, "InsertOne error: %v", err) mt.CloneCollection(options.Collection().SetWriteConcern(impossibleWc)) _, err = mt.Coll.UpdateOne(context.Background(), filter, update) we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.WriteException{}, err) assert.NotNil(mt, we.WriteConcernError, "expected write concern error, got %+v", err) }) mt.RunOpts("special slice types", noClientOpts, func(mt mtest.T) { // test special types that should be converted to a document for updates even though the underlying type is // a slice/array doc := bson.D{{"$set", bson.D{{"x", 2}}}} docBytes, err := bson.Marshal(doc) assert.Nil(mt, err, "Marshal error: %v", err) testCases := []struct { name string update interface{} }{ {"bsoncore Document", bsoncore.Document(docBytes)}, {"bson Raw", bson.Raw(docBytes)}, {"bson D", doc}, {"byte slice", docBytes}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { filter := bson.D{{"x", 1}} _, err := mt.Coll.InsertOne(context.Background(), filter) assert.Nil(mt, err, "InsertOne error: %v", err) res, err := mt.Coll.UpdateOne(context.Background(), filter, tc.update) assert.Nil(mt, err, "UpdateOne error: %v", err) assert.Equal(mt, int64(1), res.MatchedCount, "expected matched count 1, got %v", res.MatchedCount) assert.Equal(mt, int64(1), res.ModifiedCount, "expected modified count 1, got %v", res.ModifiedCount) }) } }) }) mt.RunOpts("update by id", noClientOpts, func(mt mtest.T) { mt.Run("empty update", func(mt mtest.T) { _, err := mt.Coll.UpdateByID(context.Background(), "foo", bson.D{}) assert.NotNil(mt, err, "expected error, got nil") }) mt.Run("nil id", func(mt mtest.T) { _, err := mt.Coll.UpdateByID(context.Background(), nil, bson.D{{"$inc", bson.D{{"x", 1}}}}) assert.Equal(mt, err, mongo.ErrNilValue, "expected %v, got %v", mongo.ErrNilValue, err) }) mt.RunOpts("found", noClientOpts, func(mt mtest.T) { testCases := []struct { name string id interface{} }{ {"objectID", primitive.NewObjectID()}, {"string", "foo"}, {"int", 11}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { doc := bson.D{{"_id", tc.id}, {"x", 1}} _, err := mt.Coll.InsertOne(context.Background(), doc) assert.Nil(mt, err, "InsertOne error: %v", err) update := bson.D{{"$inc", bson.D{{"x", 1}}}} res, err := mt.Coll.UpdateByID(context.Background(), tc.id, update) assert.Nil(mt, err, "UpdateByID error: %v", err) assert.Equal(mt, int64(1), res.MatchedCount, "expected matched count 1, got %v", res.MatchedCount) assert.Equal(mt, int64(1), res.ModifiedCount, "expected modified count 1, got %v", res.ModifiedCount) assert.Nil(mt, res.UpsertedID, "expected upserted ID nil, got %v", res.UpsertedID) }) } }) mt.Run("not found", func(mt mtest.T) { id := primitive.NewObjectID() doc := bson.D{{"_id", id}, {"x", 1}} _, err := mt.Coll.InsertOne(context.Background(), doc) assert.Nil(mt, err, "InsertOne error: %v", err) update := bson.D{{"$inc", bson.D{{"x", 1}}}} res, err := mt.Coll.UpdateByID(context.Background(), 0, update) assert.Nil(mt, err, "UpdateByID error: %v", err) assert.Equal(mt, int64(0), res.MatchedCount, "expected matched count 0, got %v", res.MatchedCount) assert.Equal(mt, int64(0), res.ModifiedCount, "expected modified count 0, got %v", res.ModifiedCount) assert.Nil(mt, res.UpsertedID, "expected upserted ID nil, got %v", res.UpsertedID) }) mt.Run("upsert", func(mt mtest.T) { doc := bson.D{{"_id", primitive.NewObjectID()}, {"x", 1}} _, err := mt.Coll.InsertOne(context.Background(), doc) assert.Nil(mt, err, "InsertOne error: %v", err) update := bson.D{{"$inc", bson.D{{"x", 1}}}} id := "blah" res, err := mt.Coll.UpdateByID(context.Background(), id, update, options.Update().SetUpsert(true)) assert.Nil(mt, err, "UpdateByID error: %v", err) assert.Equal(mt, int64(0), res.MatchedCount, "expected matched count 0, got %v", res.MatchedCount) assert.Equal(mt, int64(0), res.ModifiedCount, "expected modified count 0, got %v", res.ModifiedCount) assert.Equal(mt, res.UpsertedID, id, "expected upserted ID %v, got %v", id, res.UpsertedID) }) mt.Run("write error", func(mt mtest.T) { id := "foo" update := bson.D{{"$set", bson.D{{"_id", 3.14159}}}} _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"_id", id}}) assert.Nil(mt, err, "InsertOne error: %v", err) _, err = mt.Coll.UpdateByID(context.Background(), id, update) se, ok := err.(mongo.ServerError) assert.True(mt, ok, "expected ServerError, got %v", err) assert.True(mt, se.HasErrorCode(errorModifiedID), "expected error code %v, got %v", errorModifiedID, err) }) mt.RunOpts("write concern error", mtest.NewOptions().Topologies(mtest.ReplicaSet), func(mt mtest.T) { // 2.6 returns right away if the document doesn't exist id := "foo" update := bson.D{{"$set", bson.D{{"pi", 3.14159}}}} _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"_id", id}}) assert.Nil(mt, err, "InsertOne error: %v", err) mt.CloneCollection(options.Collection().SetWriteConcern(impossibleWc)) _, err = mt.Coll.UpdateByID(context.Background(), id, update) we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.WriteException{}, err) assert.NotNil(mt, we.WriteConcernError, "expected write concern error, got %+v", we) }) }) mt.RunOpts("update many", noClientOpts, func(mt mtest.T) { mt.Run("empty update", func(mt mtest.T) { _, err := mt.Coll.UpdateMany(context.Background(), bson.D{}, bson.D{}) assert.NotNil(mt, err, "expected error, got nil") }) mt.Run("found", func(mt mtest.T) { initCollection(mt, mt.Coll) filter := bson.D{{"x", bson.D{{"$gte", 3}}}} update := bson.D{{"$inc", bson.D{{"x", 1}}}} res, err := mt.Coll.UpdateMany(context.Background(), filter, update) assert.Nil(mt, err, "UpdateMany error: %v", err) assert.Equal(mt, int64(3), res.MatchedCount, "expected matched count 3, got %v", res.MatchedCount) assert.Equal(mt, int64(3), res.ModifiedCount, "expected modified count 3, got %v", res.ModifiedCount) assert.Nil(mt, res.UpsertedID, "expected upserted ID nil, got %v", res.UpsertedID) }) mt.Run("not found", func(mt mtest.T) { initCollection(mt, mt.Coll) filter := bson.D{{"x", bson.D{{"$lt", 1}}}} update := bson.D{{"$inc", bson.D{{"x", 1}}}} res, err := mt.Coll.UpdateMany(context.Background(), filter, update) assert.Nil(mt, err, "UpdateMany error: %v", err) assert.Equal(mt, int64(0), res.MatchedCount, "expected matched count 0, got %v", res.MatchedCount) assert.Equal(mt, int64(0), res.ModifiedCount, "expected modified count 0, got %v", res.ModifiedCount) assert.Nil(mt, res.UpsertedID, "expected upserted ID nil, got %v", res.UpsertedID) }) mt.Run("upsert", func(mt mtest.T) { initCollection(mt, mt.Coll) filter := bson.D{{"x", bson.D{{"$lt", 1}}}} update := bson.D{{"$inc", bson.D{{"x", 1}}}} res, err := mt.Coll.UpdateMany(context.Background(), filter, update, options.Update().SetUpsert(true)) assert.Nil(mt, err, "UpdateMany error: %v", err) assert.Equal(mt, int64(0), res.MatchedCount, "expected matched count 0, got %v", res.MatchedCount) assert.Equal(mt, int64(0), res.ModifiedCount, "expected modified count 0, got %v", res.ModifiedCount) assert.NotNil(mt, res.UpsertedID, "expected upserted ID, got nil") }) mt.Run("write error", func(mt mtest.T) { filter := bson.D{{"_id", "foo"}} update := bson.D{{"$set", bson.D{{"_id", 3.14159}}}} _, err := mt.Coll.InsertOne(context.Background(), filter) assert.Nil(mt, err, "InsertOne error: %v", err) _, err = mt.Coll.UpdateMany(context.Background(), filter, update) we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.WriteException{}, err) numWriteErrors := len(we.WriteErrors) assert.Equal(mt, 1, numWriteErrors, "expected 1 write error, got %v", numWriteErrors) gotCode := we.WriteErrors[0].Code assert.Equal(mt, errorModifiedID, gotCode, "expected error code %v, got %v", errorModifiedID, gotCode) }) mt.RunOpts("write concern error", mtest.NewOptions().Topologies(mtest.ReplicaSet), func(mt mtest.T) { // 2.6 returns right away if the document doesn't exist filter := bson.D{{"_id", "foo"}} update := bson.D{{"$set", bson.D{{"pi", 3.14159}}}} _, err := mt.Coll.InsertOne(context.Background(), filter) assert.Nil(mt, err, "InsertOne error: %v", err) mt.CloneCollection(options.Collection().SetWriteConcern(impossibleWc)) _, err = mt.Coll.UpdateMany(context.Background(), filter, update) we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.WriteException{}, err) assert.NotNil(mt, we.WriteConcernError, "expected write concern error, got %+v", we) }) }) mt.RunOpts("replace one", noClientOpts, func(mt mtest.T) { mt.Run("found", func(mt mtest.T) { initCollection(mt, mt.Coll) filter := bson.D{{"x", 1}} replacement := bson.D{{"y", 1}} res, err := mt.Coll.ReplaceOne(context.Background(), filter, replacement) assert.Nil(mt, err, "ReplaceOne error: %v", err) assert.Equal(mt, int64(1), res.MatchedCount, "expected matched count 1, got %v", res.MatchedCount) assert.Equal(mt, int64(1), res.ModifiedCount, "expected modified count 1, got %v", res.ModifiedCount) assert.Nil(mt, res.UpsertedID, "expected upserted ID nil, got %v", res.UpsertedID) }) mt.Run("not found", func(mt mtest.T) { initCollection(mt, mt.Coll) filter := bson.D{{"x", 0}} replacement := bson.D{{"y", 1}} res, err := mt.Coll.ReplaceOne(context.Background(), filter, replacement) assert.Nil(mt, err, "ReplaceOne error: %v", err) assert.Equal(mt, int64(0), res.MatchedCount, "expected matched count 0, got %v", res.MatchedCount) assert.Equal(mt, int64(0), res.ModifiedCount, "expected modified count 0, got %v", res.ModifiedCount) assert.Nil(mt, res.UpsertedID, "expected upserted ID nil, got %v", res.UpsertedID) }) mt.Run("upsert", func(mt mtest.T) { initCollection(mt, mt.Coll) filter := bson.D{{"x", 0}} replacement := bson.D{{"y", 1}} res, err := mt.Coll.ReplaceOne(context.Background(), filter, replacement, options.Replace().SetUpsert(true)) assert.Nil(mt, err, "ReplaceOne error: %v", err) assert.Equal(mt, int64(0), res.MatchedCount, "expected matched count 0, got %v", res.MatchedCount) assert.Equal(mt, int64(0), res.ModifiedCount, "expected modified count 0, got %v", res.ModifiedCount) assert.NotNil(mt, res.UpsertedID, "expected upserted ID, got nil") }) mt.Run("write error", func(mt mtest.T) { filter := bson.D{{"_id", "foo"}} replacement := bson.D{{"_id", 3.14159}} _, err := mt.Coll.InsertOne(context.Background(), filter) assert.Nil(mt, err, "InsertOne error: %v", err) _, err = mt.Coll.ReplaceOne(context.Background(), filter, replacement) we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.WriteException{}, err) numWriteErrors := len(we.WriteErrors) assert.Equal(mt, 1, numWriteErrors, "expected 1 write error, got %v", numWriteErrors) gotCode := we.WriteErrors[0].Code assert.True(mt, gotCode == errorModifiedID \|\| gotCode == errorModifiedIDLegacy, "expected error code %v or %v, got %v", errorModifiedID, errorModifiedIDLegacy, gotCode) }) mt.RunOpts("write concern error", mtest.NewOptions().Topologies(mtest.ReplicaSet), func(mt mtest.T) { // 2.6 returns right away if document doesn't exist filter := bson.D{{"_id", "foo"}} replacement := bson.D{{"pi", 3.14159}} _, err := mt.Coll.InsertOne(context.Background(), filter) assert.Nil(mt, err, "InsertOne error: %v", err) mt.CloneCollection(options.Collection().SetWriteConcern(impossibleWc)) _, err = mt.Coll.ReplaceOne(context.Background(), filter, replacement) we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.WriteException{}, err) assert.NotNil(mt, we.WriteConcernError, "expected write concern error, got nil") }) }) mt.RunOpts("aggregate", noClientOpts, func(mt mtest.T) { mt.Run("success", func(mt mtest.T) { initCollection(mt, mt.Coll) pipeline := bson.A{ bson.D{{"$match", bson.D{{"x", bson.D{{"$gte", 2}}}}}}, bson.D{{"$project", bson.D{ {"_id", 0}, {"x", 1}, }}}, bson.D{{"$sort", bson.D{{"x", 1}}}}, } cursor, err := mt.Coll.Aggregate(context.Background(), pipeline) assert.Nil(mt, err, "Aggregate error: %v", err) for i := 2; i < 5; i++ { assert.True(mt, cursor.Next(context.Background()), "expected Next true, got false (i=%v)", i) elems, _ := cursor.Current.Elements() assert.Equal(mt, 1, len(elems), "expected doc with 1 element, got %v", cursor.Current) num, err := cursor.Current.LookupErr("x") assert.Nil(mt, err, "x not found in document %v", cursor.Current) assert.Equal(mt, bson.TypeInt32, num.Type, "expected 'x' type %v, got %v", bson.TypeInt32, num.Type) assert.Equal(mt, int32(i), num.Int32(), "expected x value %v, got %v", i, num.Int32()) } }) mt.RunOpts("index hint", mtest.NewOptions().MinServerVersion("3.6"), func(mt mtest.T) { hint := bson.D{{"x", 1}} testAggregateWithOptions(mt, true, options.Aggregate().SetHint(hint)) }) mt.Run("options", func(mt mtest.T) { testAggregateWithOptions(mt, false, options.Aggregate().SetAllowDiskUse(true)) }) mt.RunOpts("single key map hint", mtest.NewOptions().MinServerVersion("3.6"), func(mt mtest.T) { hint := bson.M{"x": 1} testAggregateWithOptions(mt, true, options.Aggregate().SetHint(hint)) }) mt.RunOpts("multikey map hint", mtest.NewOptions().MinServerVersion("3.6"), func(mt mtest.T) { pipeline := mongo.Pipeline{bson.D{{"$out", mt.Coll.Name()}}} cursor, err := mt.Coll.Aggregate(context.Background(), pipeline, options.Aggregate().SetHint(bson.M{"x": 1, "y": 1})) assert.Nil(mt, cursor, "expected cursor nil, got %v", cursor) assert.Equal(mt, mongo.ErrMapForOrderedArgument{"hint"}, err, "expected error %v, got %v", mongo.ErrMapForOrderedArgument{"hint"}, err) }) wcCollOpts := options.Collection().SetWriteConcern(impossibleWc) wcTestOpts := mtest.NewOptions().Topologies(mtest.ReplicaSet).MinServerVersion("3.6").CollectionOptions(wcCollOpts) mt.RunOpts("write concern error", wcTestOpts, func(mt mtest.T) { pipeline := mongo.Pipeline{{{"$out", mt.Coll.Name()}}} cursor, err := mt.Coll.Aggregate(context.Background(), pipeline) assert.Nil(mt, cursor, "expected cursor nil, got %v", cursor) _, ok := err.(mongo.WriteConcernError) assert.True(mt, ok, "expected error type %v, got %v", mongo.WriteConcernError{}, err) }) mt.Run("getMore commands are monitored", func(mt mtest.T) { initCollection(mt, mt.Coll) assertGetMoreCommandsAreMonitored(mt, "aggregate", func() (mongo.Cursor, error) { return mt.Coll.Aggregate(context.Background(), mongo.Pipeline{}, options.Aggregate().SetBatchSize(3)) }) }) mt.Run("killCursors commands are monitored", func(mt mtest.T) { initCollection(mt, mt.Coll) assertKillCursorsCommandsAreMonitored(mt, "aggregate", func() (mongo.Cursor, error) { return mt.Coll.Aggregate(context.Background(), mongo.Pipeline{}, options.Aggregate().SetBatchSize(3)) }) }) mt.Run("Custom", func(mt mtest.T) { // Custom options should be a BSON map of option names to Marshalable option values. // We use "allowDiskUse" as an example. customOpts := bson.M{"allowDiskUse": true} opts := options.Aggregate().SetCustom(customOpts) // Run aggregate with custom options set. mt.ClearEvents() _, err := mt.Coll.Aggregate(context.Background(), mongo.Pipeline{}, opts) assert.Nil(mt, err, "Aggregate error: %v", err) // Assert that custom option is passed to the aggregate expression. evt := mt.GetStartedEvent() assert.Equal(mt, "aggregate", evt.CommandName, "expected command 'aggregate' got, %q", evt.CommandName) aduVal, err := evt.Command.LookupErr("allowDiskUse") assert.Nil(mt, err, "expected field 'allowDiskUse' in started command not found") adu, ok := aduVal.BooleanOK() assert.True(mt, ok, "expected field 'allowDiskUse' to be boolean, got %v", aduVal.Type.String()) assert.True(mt, adu, "expected field 'allowDiskUse' to be true, got false") }) }) mt.RunOpts("count documents", noClientOpts, func(mt mtest.T) { mt.Run("success", func(mt mtest.T) { testCases := []struct { name string filter bson.D opts options.CountOptions count int64 testOpts mtest.Options }{ {"no filter", bson.D{}, nil, 5, mtest.NewOptions()}, {"filter", bson.D{{"x", bson.D{{"$gt", 2}}}}, nil, 3, mtest.NewOptions()}, {"limit", bson.D{}, options.Count().SetLimit(3), 3, mtest.NewOptions()}, {"skip", bson.D{}, options.Count().SetSkip(3), 2, mtest.NewOptions()}, {"single key map hint", bson.D{}, options.Count().SetHint(bson.M{"x": 1}), 5, mtest.NewOptions().MinServerVersion("3.6")}, } for _, tc := range testCases { mt.RunOpts(tc.name, tc.testOpts, func(mt mtest.T) { initCollection(mt, mt.Coll) indexView := mt.Coll.Indexes() _, err := indexView.CreateOne(context.Background(), mongo.IndexModel{ Keys: bson.D{{"x", 1}}, }) assert.Nil(mt, err, "CreateOne error: %v", err) count, err := mt.Coll.CountDocuments(context.Background(), tc.filter, tc.opts) assert.Nil(mt, err, "CountDocuments error: %v", err) assert.Equal(mt, tc.count, count, "expected count %v, got %v", tc.count, count) }) } }) mt.Run("multikey map hint", func(mt mtest.T) { opts := options.Count().SetHint(bson.M{"x": 1, "y": 1}) _, err := mt.Coll.CountDocuments(context.Background(), bson.D{}, opts) assert.Equal(mt, mongo.ErrMapForOrderedArgument{"hint"}, err, "expected error %v, got %v", mongo.ErrMapForOrderedArgument{"hint"}, err) }) }) mt.RunOpts("estimated document count", noClientOpts, func(mt mtest.T) { testCases := []struct { name string opts options.EstimatedDocumentCountOptions count int64 }{ {"no options", nil, 5}, {"options", options.EstimatedDocumentCount().SetMaxTime(1 * time.Second), 5}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { initCollection(mt, mt.Coll) count, err := mt.Coll.EstimatedDocumentCount(context.Background(), tc.opts) assert.Nil(mt, err, "EstimatedDocumentCount error: %v", err) assert.Equal(mt, tc.count, count, "expected count %v, got %v", tc.count, count) }) } }) mt.RunOpts("distinct", noClientOpts, func(mt mtest.T) { all := []interface{}{int32(1), int32(2), int32(3), int32(4), int32(5)} last3 := []interface{}{int32(3), int32(4), int32(5)} testCases := []struct { name string filter bson.D opts options.DistinctOptions expected []interface{} }{ {"no options", bson.D{}, nil, all}, {"filter", bson.D{{"x", bson.D{{"$gt", 2}}}}, nil, last3}, {"options", bson.D{}, options.Distinct().SetMaxTime(5000000000), all}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { initCollection(mt, mt.Coll) res, err := mt.Coll.Distinct(context.Background(), "x", tc.filter, tc.opts) assert.Nil(mt, err, "Distinct error: %v", err) assert.Equal(mt, tc.expected, res, "expected result %v, got %v", tc.expected, res) }) } }) mt.RunOpts("find", noClientOpts, func(mt mtest.T) { mt.Run("found", func(mt mtest.T) { initCollection(mt, mt.Coll) cursor, err := mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetSort(bson.D{{"x", 1}})) assert.Nil(mt, err, "Find error: %v", err) results := make([]int, 0, 5) for cursor.Next(context.Background()) { x, err := cursor.Current.LookupErr("x") assert.Nil(mt, err, "x not found in document %v", cursor.Current) assert.Equal(mt, bson.TypeInt32, x.Type, "expected x type %v, got %v", bson.TypeInt32, x.Type) results = append(results, int(x.Int32())) } assert.Equal(mt, 5, len(results), "expected 5 results, got %v", len(results)) expected := []int{1, 2, 3, 4, 5} assert.Equal(mt, expected, results, "expected results %v, got %v", expected, results) }) mt.Run("limit and batch size", func(mt mtest.T) { initCollection(mt, mt.Coll) for _, batchSize := range []int32{2, 3, 4} { cursor, err := mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetLimit(3).SetBatchSize(batchSize)) assert.Nil(mt, err, "Find error: %v", err) numReceived := 0 for cursor.Next(context.Background()) { numReceived++ } err = cursor.Err() assert.Nil(mt, err, "cursor error: %v", err) assert.Equal(mt, 3, numReceived, "expected 3 results, got %v", numReceived) } }) mt.Run("not found", func(mt mtest.T) { initCollection(mt, mt.Coll) cursor, err := mt.Coll.Find(context.Background(), bson.D{{"x", 6}}) assert.Nil(mt, err, "Find error: %v", err) assert.False(mt, cursor.Next(context.Background()), "expected no documents, found %v", cursor.Current) }) mt.Run("invalid identifier error", func(mt mtest.T) { cursor, err := mt.Coll.Find(context.Background(), bson.D{{"$foo", 1}}) assert.NotNil(mt, err, "expected error for invalid identifier, got nil") assert.Nil(mt, cursor, "expected nil cursor, got %v", cursor) }) mt.Run("negative limit", func(mt mtest.T) { initCollection(mt, mt.Coll) c, err := mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetLimit(-2)) assert.Nil(mt, err, "Find error: %v", err) // single batch returned so cursor should have ID 0 assert.Equal(mt, int64(0), c.ID(), "expected cursor ID 0, got %v", c.ID()) var numDocs int for c.Next(context.Background()) { numDocs++ } assert.Equal(mt, 2, numDocs, "expected 2 documents, got %v", numDocs) }) mt.Run("exhaust cursor", func(mt mtest.T) { initCollection(mt, mt.Coll) c, err := mt.Coll.Find(context.Background(), bson.D{}) assert.Nil(mt, err, "Find error: %v", err) var numDocs int for c.Next(context.Background()) { numDocs++ } assert.Equal(mt, 5, numDocs, "expected 5 documents, got %v", numDocs) err = c.Close(context.Background()) assert.Nil(mt, err, "Close error: %v", err) }) mt.Run("hint", func(mt mtest.T) { _, err := mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetHint("_id_")) assert.Nil(mt, err, "Find error with string hint: %v", err) _, err = mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetHint(bson.D{{"_id", 1}})) assert.Nil(mt, err, "Find error with document hint: %v", err) _, err = mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetHint("foobar")) _, ok := err.(mongo.CommandError) assert.True(mt, ok, "expected error type %v, got %v", mongo.CommandError{}, err) _, err = mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetHint(bson.M{"_id": 1})) assert.Nil(mt, err, "Find error with single key map hint: %v", err) _, err = mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetHint(bson.M{"_id": 1, "x": 1})) assert.Equal(mt, mongo.ErrMapForOrderedArgument{"hint"}, err, "expected error %v, got %v", mongo.ErrMapForOrderedArgument{"hint"}, err) }) mt.Run("sort", func(mt mtest.T) { _, err := mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetSort(bson.M{"_id": 1})) assert.Nil(mt, err, "Find error with single key map sort: %v", err) _, err = mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetSort(bson.M{"_id": 1, "x": 1})) assert.Equal(mt, mongo.ErrMapForOrderedArgument{"sort"}, err, "expected error %v, got %v", mongo.ErrMapForOrderedArgument{"sort"}, err) }) mt.Run("limit and batch size and skip", func(mt mtest.T) { testCases := []struct { limit int64 batchSize int32 skip int64 name string }{ { 99, 100, 10, "case 1", }, { 100, 100, 20, "case 2", }, { 80, 20, 90, "case 3", }, { 201, 201, 0, "case 4", }, { 100, 200, 120, "case 5", }, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { var insertDocs []interface{} for i := 1; i <= 201; i++ { insertDocs = append(insertDocs, bson.D{{"x", int32(i)}}) } _, err := mt.Coll.InsertMany(context.Background(), insertDocs) assert.Nil(mt, err, "InsertMany error for initial data: %v", err) findOptions := options.Find().SetLimit(tc.limit).SetBatchSize(tc.batchSize). SetSkip(tc.skip) cursor, err := mt.Coll.Find(context.Background(), bson.D{}, findOptions) assert.Nil(mt, err, "Find error: %v", err) var docs []interface{} err = cursor.All(context.Background(), &docs) assert.Nil(mt, err, "All error: %v", err) if (201 - tc.skip) < tc.limit { assert.Equal(mt, int(201-tc.skip), len(docs), "expected number of docs to be %v, got %v", int(201-tc.skip), len(docs)) } else { assert.Equal(mt, int(tc.limit), len(docs), "expected number of docs to be %v, got %v", tc.limit, len(docs)) } }) } }) mt.Run("unset batch size does not surpass limit", func(mt mtest.T) { testCases := []struct { limit int64 name string }{ { 99, "99", }, { 100, "100", }, { 101, "101", }, { 200, "200", }, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { var insertDocs []interface{} for i := 1; i <= 201; i++ { insertDocs = append(insertDocs, bson.D{{"x", int32(i)}}) } _, err := mt.Coll.InsertMany(context.Background(), insertDocs) assert.Nil(mt, err, "InsertMany error for initial data: %v", err) opts := options.Find().SetSkip(0).SetLimit(tc.limit) cursor, err := mt.Coll.Find(context.Background(), bson.D{}, opts) assert.Nil(mt, err, "Find error with limit %v: %v", tc.limit, err) var docs []interface{} err = cursor.All(context.Background(), &docs) assert.Nil(mt, err, "All error with limit %v: %v", tc.limit, err) assert.Equal(mt, int(tc.limit), len(docs), "expected number of docs to be %v, got %v", tc.limit, len(docs)) }) } }) mt.Run("getMore commands are monitored", func(mt mtest.T) { initCollection(mt, mt.Coll) assertGetMoreCommandsAreMonitored(mt, "find", func() (mongo.Cursor, error) { return mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetBatchSize(3)) }) }) mt.Run("killCursors commands are monitored", func(mt mtest.T) { initCollection(mt, mt.Coll) assertKillCursorsCommandsAreMonitored(mt, "find", func() (mongo.Cursor, error) { return mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetBatchSize(3)) }) }) }) mt.RunOpts("find one", noClientOpts, func(mt mtest.T) { mt.Run("limit", func(mt mtest.T) { err := mt.Coll.FindOne(context.Background(), bson.D{}).Err() assert.Equal(mt, mongo.ErrNoDocuments, err, "expected error %v, got %v", mongo.ErrNoDocuments, err) started := mt.GetStartedEvent() assert.NotNil(mt, started, "expected CommandStartedEvent, got nil") limitVal, err := started.Command.LookupErr("limit") assert.Nil(mt, err, "limit not found in command") limit := limitVal.Int64() assert.Equal(mt, int64(1), limit, "expected limit 1, got %v", limit) }) mt.Run("found", func(mt mtest.T) { initCollection(mt, mt.Coll) res, err := mt.Coll.FindOne(context.Background(), bson.D{{"x", 1}}).Raw() assert.Nil(mt, err, "FindOne error: %v", err) x, err := res.LookupErr("x") assert.Nil(mt, err, "x not found in document %v", res) assert.Equal(mt, bson.TypeInt32, x.Type, "expected x type %v, got %v", bson.TypeInt32, x.Type) got := x.Int32() assert.Equal(mt, int32(1), got, "expected x value 1, got %v", got) }) mt.RunOpts("options", mtest.NewOptions().MinServerVersion("3.4"), func(mt mtest.T) { initCollection(mt, mt.Coll) // Create an index for Hint, Max, and Min options indexView := mt.Coll.Indexes() indexName, err := indexView.CreateOne(context.Background(), mongo.IndexModel{ Keys: bson.D{{"x", 1}}, }) assert.Nil(mt, err, "CreateOne error: %v", err) mt.ClearEvents() expectedComment := "here's a query for ya" // SetCursorType is excluded because tailable cursors can't be used with limit -1, // which all FindOne operations set, and the nontailable setting isn't passed to the // operation layer // SetMaxAwaitTime affects the cursor and not the server command, so it can't be checked // SetCursorTime and setMaxAwaitTime will be deprecated in GODRIVER-1775 opts := options.FindOne(). SetAllowPartialResults(true). SetBatchSize(2). SetCollation(&options.Collation{Locale: "en_US"}). SetComment(expectedComment). SetHint(indexName). SetMax(bson.D{{"x", int32(5)}}). SetMaxTime(1 time.Second). SetMin(bson.D{{"x", int32(0)}}). SetNoCursorTimeout(false). SetOplogReplay(false). SetProjection(bson.D{{"x", int32(1)}}). SetReturnKey(false). SetShowRecordID(false). SetSkip(0). SetSort(bson.D{{"x", int32(1)}}) res, err := mt.Coll.FindOne(context.Background(), bson.D{}, opts).Raw() assert.Nil(mt, err, "FindOne error: %v", err) x, err := res.LookupErr("x") assert.Nil(mt, err, "x not found in document %v", res) assert.Equal(mt, bson.TypeInt32, x.Type, "expected x type %v, got %v", bson.TypeInt32, x.Type) got := x.Int32() assert.Equal(mt, int32(1), got, "expected x value 1, got %v", got) optionsDoc := bsoncore.NewDocumentBuilder(). AppendBoolean("allowPartialResults", true). AppendInt32("batchSize", 2). StartDocument("collation").AppendString("locale", "en_US").FinishDocument(). AppendString("comment", expectedComment). AppendString("hint", indexName). StartDocument("max").AppendInt32("x", 5).FinishDocument(). AppendInt32("maxTimeMS", 1000). StartDocument("min").AppendInt32("x", 0).FinishDocument(). AppendBoolean("noCursorTimeout", false). AppendBoolean("oplogReplay", false). StartDocument("projection").AppendInt32("x", 1).FinishDocument(). AppendBoolean("returnKey", false). AppendBoolean("showRecordId", false). AppendInt64("skip", 0). StartDocument("sort").AppendInt32("x", 1).FinishDocument(). Build() started := mt.GetStartedEvent() assert.NotNil(mt, started, "expected CommandStartedEvent, got nil") if err := compareDocs(mt, bson.Raw(optionsDoc), started.Command); err != nil { mt.Fatalf("options mismatch: %v", err) } }) mt.Run("not found", func(mt mtest.T) { initCollection(mt, mt.Coll) err := mt.Coll.FindOne(context.Background(), bson.D{{"x", 6}}).Err() assert.Equal(mt, mongo.ErrNoDocuments, err, "expected error %v, got %v", mongo.ErrNoDocuments, err) }) mt.RunOpts("maps for sorted opts", noClientOpts, func(mt mtest.T) { testCases := []struct { name string opts options.FindOneOptions errParam string }{ {"single key hint", options.FindOne().SetHint(bson.M{"x": 1}), ""}, {"multikey hint", options.FindOne().SetHint(bson.M{"x": 1, "y": 1}), "hint"}, {"single key sort", options.FindOne().SetSort(bson.M{"x": 1}), ""}, {"multikey sort", options.FindOne().SetSort(bson.M{"x": 1, "y": 1}), "sort"}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { initCollection(mt, mt.Coll) indexView := mt.Coll.Indexes() _, err := indexView.CreateOne(context.Background(), mongo.IndexModel{ Keys: bson.D{{"x", 1}}, }) assert.Nil(mt, err, "CreateOne error: %v", err) res, err := mt.Coll.FindOne(context.Background(), bson.D{{"x", 1}}, tc.opts).Raw() if tc.errParam != "" { expErr := mongo.ErrMapForOrderedArgument{tc.errParam} assert.Equal(mt, expErr, err, "expected error %v, got %v", expErr, err) return } assert.Nil(mt, err, "FindOne error: %v", err) x, err := res.LookupErr("x") assert.Nil(mt, err, "x not found in document %v", res) got, ok := x.Int32OK() assert.True(mt, ok, "expected x type int32, got %v", x.Type) assert.Equal(mt, int32(1), got, "expected x value 1, got %v", got) }) } }) }) mt.RunOpts("find one and delete", noClientOpts, func(mt mtest.T) { mt.Run("found", func(mt mtest.T) { initCollection(mt, mt.Coll) res, err := mt.Coll.FindOneAndDelete(context.Background(), bson.D{{"x", 3}}).Raw() assert.Nil(mt, err, "FindOneAndDelete error: %v", err) elem, err := res.LookupErr("x") assert.Nil(mt, err, "x not found in result %v", res) assert.Equal(mt, bson.TypeInt32, elem.Type, "expected x type %v, got %v", bson.TypeInt32, elem.Type) x := elem.Int32() assert.Equal(mt, int32(3), x, "expected x value 3, got %v", x) }) mt.Run("found ignore result", func(mt mtest.T) { initCollection(mt, mt.Coll) err := mt.Coll.FindOneAndDelete(context.Background(), bson.D{{"x", 3}}).Err() assert.Nil(mt, err, "FindOneAndDelete error: %v", err) }) mt.Run("not found", func(mt mtest.T) { initCollection(mt, mt.Coll) err := mt.Coll.FindOneAndDelete(context.Background(), bson.D{{"x", 6}}).Err() assert.Equal(mt, mongo.ErrNoDocuments, err, "expected error %v, got %v", mongo.ErrNoDocuments, err) }) mt.RunOpts("maps for sorted opts", noClientOpts, func(mt mtest.T) { testCases := []struct { name string opts options.FindOneAndDeleteOptions errParam string }{ {"single key hint", options.FindOneAndDelete().SetHint(bson.M{"x": 1}), ""}, {"multikey hint", options.FindOneAndDelete().SetHint(bson.M{"x": 1, "y": 1}), "hint"}, {"single key sort", options.FindOneAndDelete().SetSort(bson.M{"x": 1}), ""}, {"multikey sort", options.FindOneAndDelete().SetSort(bson.M{"x": 1, "y": 1}), "sort"}, } for _, tc := range testCases { mt.RunOpts(tc.name, mtest.NewOptions().MinServerVersion("4.4"), func(mt mtest.T) { initCollection(mt, mt.Coll) indexView := mt.Coll.Indexes() _, err := indexView.CreateOne(context.Background(), mongo.IndexModel{ Keys: bson.D{{"x", 1}}, }) assert.Nil(mt, err, "CreateOne error: %v", err) res, err := mt.Coll.FindOneAndDelete(context.Background(), bson.D{{"x", 1}}, tc.opts).Raw() if tc.errParam != "" { expErr := mongo.ErrMapForOrderedArgument{tc.errParam} assert.Equal(mt, expErr, err, "expected error %v, got %v", expErr, err) return } assert.Nil(mt, err, "FindOneAndDelete error: %v", err) x, err := res.LookupErr("x") assert.Nil(mt, err, "x not found in document %v", res) got, ok := x.Int32OK() assert.True(mt, ok, "expected x type int32, got %v", x.Type) assert.Equal(mt, int32(1), got, "expected x value 1, got %v", got) }) } }) wcCollOpts := options.Collection().SetWriteConcern(impossibleWc) wcTestOpts := mtest.NewOptions().CollectionOptions(wcCollOpts).Topologies(mtest.ReplicaSet).MinServerVersion("3.2") mt.RunOpts("write concern error", wcTestOpts, func(mt mtest.T) { err := mt.Coll.FindOneAndDelete(context.Background(), bson.D{{"x", 3}}).Err() we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.WriteException{}, err) assert.NotNil(mt, we.WriteConcernError, "expected write concern error, got %v", err) }) }) mt.RunOpts("find one and replace", noClientOpts, func(mt mtest.T) { mt.Run("found", func(mt mtest.T) { initCollection(mt, mt.Coll) filter := bson.D{{"x", 3}} replacement := bson.D{{"y", 3}} res, err := mt.Coll.FindOneAndReplace(context.Background(), filter, replacement).Raw() assert.Nil(mt, err, "FindOneAndReplace error: %v", err) elem, err := res.LookupErr("x") assert.Nil(mt, err, "x not found in result %v", res) assert.Equal(mt, bson.TypeInt32, elem.Type, "expected x type %v, got %v", bson.TypeInt32, elem.Type) x := elem.Int32() assert.Equal(mt, int32(3), x, "expected x value 3, got %v", x) }) mt.Run("found ignore result", func(mt mtest.T) { initCollection(mt, mt.Coll) filter := bson.D{{"x", 3}} replacement := bson.D{{"y", 3}} err := mt.Coll.FindOneAndReplace(context.Background(), filter, replacement).Err() assert.Nil(mt, err, "FindOneAndReplace error: %v", err) }) mt.Run("not found", func(mt mtest.T) { initCollection(mt, mt.Coll) filter := bson.D{{"x", 6}} replacement := bson.D{{"y", 6}} err := mt.Coll.FindOneAndReplace(context.Background(), filter, replacement).Err() assert.Equal(mt, mongo.ErrNoDocuments, err, "expected error %v, got %v", mongo.ErrNoDocuments, err) }) mt.RunOpts("maps for sorted opts", noClientOpts, func(mt mtest.T) { testCases := []struct { name string opts options.FindOneAndReplaceOptions errParam string }{ {"single key hint", options.FindOneAndReplace().SetHint(bson.M{"x": 1}), ""}, {"multikey hint", options.FindOneAndReplace().SetHint(bson.M{"x": 1, "y": 1}), "hint"}, {"single key sort", options.FindOneAndReplace().SetSort(bson.M{"x": 1}), ""}, {"multikey sort", options.FindOneAndReplace().SetSort(bson.M{"x": 1, "y": 1}), "sort"}, } for _, tc := range testCases { mt.RunOpts(tc.name, mtest.NewOptions().MinServerVersion("4.4"), func(mt mtest.T) { initCollection(mt, mt.Coll) indexView := mt.Coll.Indexes() _, err := indexView.CreateOne(context.Background(), mongo.IndexModel{ Keys: bson.D{{"x", 1}}, }) assert.Nil(mt, err, "CreateOne error: %v", err) res, err := mt.Coll.FindOneAndReplace(context.Background(), bson.D{{"x", 1}}, bson.D{{"y", 3}}, tc.opts).Raw() if tc.errParam != "" { expErr := mongo.ErrMapForOrderedArgument{tc.errParam} assert.Equal(mt, expErr, err, "expected error %v, got %v", expErr, err) return } assert.Nil(mt, err, "FindOneAndReplace error: %v", err) x, err := res.LookupErr("x") assert.Nil(mt, err, "x not found in document %v", res) got, ok := x.Int32OK() assert.True(mt, ok, "expected x type int32, got %v", x.Type) assert.Equal(mt, int32(1), got, "expected x value 1, got %v", got) }) } }) wcCollOpts := options.Collection().SetWriteConcern(impossibleWc) wcTestOpts := mtest.NewOptions().CollectionOptions(wcCollOpts).Topologies(mtest.ReplicaSet).MinServerVersion("3.2") mt.RunOpts("write concern error", wcTestOpts, func(mt mtest.T) { filter := bson.D{{"x", 3}} replacement := bson.D{{"y", 3}} err := mt.Coll.FindOneAndReplace(context.Background(), filter, replacement).Err() we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.WriteException{}, err) assert.NotNil(mt, we.WriteConcernError, "expected write concern error, got %v", err) }) }) mt.RunOpts("find one and update", noClientOpts, func(mt mtest.T) { mt.Run("found", func(mt mtest.T) { initCollection(mt, mt.Coll) filter := bson.D{{"x", 3}} update := bson.D{{"$set", bson.D{{"x", 6}}}} res, err := mt.Coll.FindOneAndUpdate(context.Background(), filter, update).Raw() assert.Nil(mt, err, "FindOneAndUpdate error: %v", err) elem, err := res.LookupErr("x") assert.Nil(mt, err, "x not found in result %v", res) assert.Equal(mt, bson.TypeInt32, elem.Type, "expected x type %v, got %v", bson.TypeInt32, elem.Type) x := elem.Int32() assert.Equal(mt, int32(3), x, "expected x value 3, got %v", x) }) mt.Run("empty update", func(mt mtest.T) { err := mt.Coll.FindOneAndUpdate(context.Background(), bson.D{}, bson.D{}) assert.NotNil(mt, err, "expected error, got nil") }) mt.Run("found ignore result", func(mt mtest.T) { initCollection(mt, mt.Coll) filter := bson.D{{"x", 3}} update := bson.D{{"$set", bson.D{{"x", 6}}}} err := mt.Coll.FindOneAndUpdate(context.Background(), filter, update).Err() assert.Nil(mt, err, "FindOneAndUpdate error: %v", err) }) mt.Run("not found", func(mt mtest.T) { initCollection(mt, mt.Coll) filter := bson.D{{"x", 6}} update := bson.D{{"$set", bson.D{{"y", 6}}}} err := mt.Coll.FindOneAndUpdate(context.Background(), filter, update).Err() assert.Equal(mt, mongo.ErrNoDocuments, err, "expected error %v, got %v", mongo.ErrNoDocuments, err) }) mt.RunOpts("maps for sorted opts", noClientOpts, func(mt mtest.T) { testCases := []struct { name string opts options.FindOneAndUpdateOptions errParam string }{ {"single key hint", options.FindOneAndUpdate().SetHint(bson.M{"x": 1}), ""}, {"multikey hint", options.FindOneAndUpdate().SetHint(bson.M{"x": 1, "y": 1}), "hint"}, {"single key sort", options.FindOneAndUpdate().SetSort(bson.M{"x": 1}), ""}, {"multikey sort", options.FindOneAndUpdate().SetSort(bson.M{"x": 1, "y": 1}), "sort"}, } for _, tc := range testCases { mt.RunOpts(tc.name, mtest.NewOptions().MinServerVersion("4.4"), func(mt mtest.T) { initCollection(mt, mt.Coll) indexView := mt.Coll.Indexes() _, err := indexView.CreateOne(context.Background(), mongo.IndexModel{ Keys: bson.D{{"x", 1}}, }) assert.Nil(mt, err, "CreateOne error: %v", err) res, err := mt.Coll.FindOneAndUpdate(context.Background(), bson.D{{"x", 1}}, bson.D{{"$set", bson.D{{"x", 6}}}}, tc.opts).Raw() if tc.errParam != "" { expErr := mongo.ErrMapForOrderedArgument{tc.errParam} assert.Equal(mt, expErr, err, "expected error %v, got %v", expErr, err) return } assert.Nil(mt, err, "FindOneAndUpdate error: %v", err) x, err := res.LookupErr("x") assert.Nil(mt, err, "x not found in document %v", res) got, ok := x.Int32OK() assert.True(mt, ok, "expected x type int32, got %v", x.Type) assert.Equal(mt, int32(1), got, "expected x value 1, got %v", got) }) } }) wcCollOpts := options.Collection().SetWriteConcern(impossibleWc) wcTestOpts := mtest.NewOptions().CollectionOptions(wcCollOpts).Topologies(mtest.ReplicaSet).MinServerVersion("3.2") mt.RunOpts("write concern error", wcTestOpts, func(mt mtest.T) { filter := bson.D{{"x", 3}} update := bson.D{{"$set", bson.D{{"x", 6}}}} err := mt.Coll.FindOneAndUpdate(context.Background(), filter, update).Err() we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.WriteException{}, err) assert.NotNil(mt, we.WriteConcernError, "expected write concern error, got %v", err) }) }) mt.RunOpts("bulk write", noClientOpts, func(mt mtest.T) { wcCollOpts := options.Collection().SetWriteConcern(impossibleWc) wcTestOpts := mtest.NewOptions().CollectionOptions(wcCollOpts).Topologies(mtest.ReplicaSet).CreateClient(false) mt.RunOpts("write concern error", wcTestOpts, func(mt mtest.T) { filter := bson.D{{"foo", "bar"}} update := bson.D{{"$set", bson.D{{"foo", 10}}}} insertModel := mongo.NewInsertOneModel().SetDocument(bson.D{{"foo", 1}}) updateModel := mongo.NewUpdateOneModel().SetFilter(filter).SetUpdate(update) deleteModel := mongo.NewDeleteOneModel().SetFilter(filter) testCases := []struct { name string models []mongo.WriteModel }{ {"insert", []mongo.WriteModel{insertModel}}, {"update", []mongo.WriteModel{updateModel}}, {"delete", []mongo.WriteModel{deleteModel}}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { _, err := mt.Coll.BulkWrite(context.Background(), tc.models) bwe, ok := err.(mongo.BulkWriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.BulkWriteException{}, err) numWriteErrors := len(bwe.WriteErrors) assert.Equal(mt, 0, numWriteErrors, "expected 0 write errors, got %v", numWriteErrors) assert.NotNil(mt, bwe.WriteConcernError, "expected write concern error, got %v", err) }) } }) mt.RunOpts("insert write errors", noClientOpts, func(mt mtest.T) { doc1 := mongo.NewInsertOneModel().SetDocument(bson.D{{"_id", "x"}}) doc2 := mongo.NewInsertOneModel().SetDocument(bson.D{{"_id", "y"}}) models := []mongo.WriteModel{doc1, doc1, doc2, doc2} testCases := []struct { name string ordered bool insertedCount int64 numWriteErrors int }{ {"ordered", true, 1, 1}, {"unordered", false, 2, 2}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { res, err := mt.Coll.BulkWrite(context.Background(), models, options.BulkWrite().SetOrdered(tc.ordered)) assert.Equal(mt, tc.insertedCount, res.InsertedCount, "expected inserted count %v, got %v", tc.insertedCount, res.InsertedCount) bwe, ok := err.(mongo.BulkWriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.BulkWriteException{}, err) numWriteErrors := len(bwe.WriteErrors) assert.Equal(mt, tc.numWriteErrors, numWriteErrors, "expected %v write errors, got %v", tc.numWriteErrors, numWriteErrors) gotCode := bwe.WriteErrors[0].Code assert.Equal(mt, errorDuplicateKey, gotCode, "expected error code %v, got %v", errorDuplicateKey, gotCode) }) } }) mt.RunOpts("delete write errors", mtest.NewOptions().MaxServerVersion("5.0.7"), func(mt mtest.T) { // Deletes are not allowed on capped collections on MongoDB 5.0.6-. We use this // behavior to test the processing of write errors. doc := mongo.NewDeleteOneModel().SetFilter(bson.D{{"x", 1}}) models := []mongo.WriteModel{doc, doc} cappedOpts := options.CreateCollection().SetCapped(true).SetSizeInBytes(64 1024) capped := mt.CreateCollection(mtest.Collection{ Name: "delete_write_errors", CreateOpts: cappedOpts, }, true) testCases := []struct { name string ordered bool numWriteErrors int }{ {"ordered", true, 1}, {"unordered", false, 2}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { _, err := capped.BulkWrite(context.Background(), models, options.BulkWrite().SetOrdered(tc.ordered)) bwe, ok := err.(mongo.BulkWriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.BulkWriteException{}, err) numWriteErrors := len(bwe.WriteErrors) assert.Equal(mt, tc.numWriteErrors, numWriteErrors, "expected %v write errors, got %v", tc.numWriteErrors, numWriteErrors) gotCode := bwe.WriteErrors[0].Code assert.True(mt, gotCode == errorCappedCollDeleteLegacy \|\| gotCode == errorCappedCollDelete, "expected error code %v or %v, got %v", errorCappedCollDeleteLegacy, errorCappedCollDelete, gotCode) }) } }) mt.RunOpts("update write errors", noClientOpts, func(mt mtest.T) { filter := bson.D{{"_id", "foo"}} doc1 := mongo.NewUpdateOneModel().SetFilter(filter).SetUpdate(bson.D{{"$set", bson.D{{"_id", 3.14159}}}}) doc2 := mongo.NewUpdateOneModel().SetFilter(filter).SetUpdate(bson.D{{"$set", bson.D{{"x", "fa"}}}}) models := []mongo.WriteModel{doc1, doc1, doc2} testCases := []struct { name string ordered bool modifiedCount int64 numWriteErrors int }{ {"ordered", true, 0, 1}, {"unordered", false, 1, 2}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { _, err := mt.Coll.InsertOne(context.Background(), filter) assert.Nil(mt, err, "InsertOne error: %v", err) res, err := mt.Coll.BulkWrite(context.Background(), models, options.BulkWrite().SetOrdered(tc.ordered)) assert.Equal(mt, tc.modifiedCount, res.ModifiedCount, "expected modified count %v, got %v", tc.modifiedCount, res.ModifiedCount) bwe, ok := err.(mongo.BulkWriteException) assert.True(mt, ok, "expected error type %v, got %v", mongo.BulkWriteException{}, err) numWriteErrors := len(bwe.WriteErrors) assert.Equal(mt, tc.numWriteErrors, numWriteErrors, "expected %v write errors, got %v", tc.numWriteErrors, numWriteErrors) gotCode := bwe.WriteErrors[0].Code assert.Equal(mt, errorModifiedID, gotCode, "expected error code %v, got %v", errorModifiedID, gotCode) }) } }) mt.Run("correct model in errors", func(mt mtest.T) { models := []mongo.WriteModel{ mongo.NewUpdateOneModel().SetFilter(bson.M{}).SetUpdate(bson.M{ "$set": bson.M{ "x": 1, }, }), mongo.NewInsertOneModel().SetDocument(bson.M{ "_id": "notduplicate", }), mongo.NewInsertOneModel().SetDocument(bson.M{ "_id": "duplicate1", }), mongo.NewInsertOneModel().SetDocument(bson.M{ "_id": "duplicate1", }), mongo.NewInsertOneModel().SetDocument(bson.M{ "_id": "duplicate2", }), mongo.NewInsertOneModel().SetDocument(bson.M{ "_id": "duplicate2", }), } _, err := mt.Coll.BulkWrite(context.Background(), models) bwException, ok := err.(mongo.BulkWriteException) assert.True(mt, ok, "expected error of type %T, got %T", mongo.BulkWriteException{}, err) expectedModel := models[3] actualModel := bwException.WriteErrors[0].Request assert.Equal(mt, expectedModel, actualModel, "expected model %v in BulkWriteException, got %v", expectedModel, actualModel) }) mt.RunOpts("unordered writeError index", mtest.NewOptions().MaxServerVersion("5.0.7"), func(mt mtest.T) { // Deletes are not allowed on capped collections on MongoDB 5.0.6-. We use this // behavior to test the processing of write errors. cappedOpts := options.CreateCollection().SetCapped(true).SetSizeInBytes(64 1024) capped := mt.CreateCollection(mtest.Collection{ Name: "deleteOne_capped", CreateOpts: cappedOpts, }, true) models := []mongo.WriteModel{ mongo.NewInsertOneModel().SetDocument(bson.D{{"_id", "id1"}}), mongo.NewInsertOneModel().SetDocument(bson.D{{"_id", "id3"}}), } _, err := capped.BulkWrite(context.Background(), models, options.BulkWrite()) assert.Nil(t, err, "BulkWrite error: %v", err) // UpdateOne and ReplaceOne models are batched together, so they each appear once models = []mongo.WriteModel{ mongo.NewDeleteOneModel().SetFilter(bson.D{{"_id", "id0"}}), mongo.NewDeleteManyModel().SetFilter(bson.D{{"_id", "id0"}}), mongo.NewUpdateOneModel().SetFilter(bson.D{{"_id", "id3"}}).SetUpdate(bson.D{{"$set", bson.D{{"_id", 3.14159}}}}), mongo.NewInsertOneModel().SetDocument(bson.D{{"_id", "id1"}}), mongo.NewDeleteManyModel().SetFilter(bson.D{{"_id", "id0"}}), mongo.NewUpdateManyModel().SetFilter(bson.D{{"_id", "id3"}}).SetUpdate(bson.D{{"$set", bson.D{{"_id", 3.14159}}}}), mongo.NewDeleteOneModel().SetFilter(bson.D{{"_id", "id0"}}), mongo.NewInsertOneModel().SetDocument(bson.D{{"_id", "id1"}}), mongo.NewReplaceOneModel().SetFilter(bson.D{{"_id", "id3"}}).SetReplacement(bson.D{{"_id", 3.14159}}), mongo.NewUpdateManyModel().SetFilter(bson.D{{"_id", "id3"}}).SetUpdate(bson.D{{"$set", bson.D{{"_id", 3.14159}}}}), } _, err = capped.BulkWrite(context.Background(), models, options.BulkWrite().SetOrdered(false)) bwException, ok := err.(mongo.BulkWriteException) assert.True(mt, ok, "expected error of type %T, got %T", mongo.BulkWriteException{}, err) assert.Equal(mt, len(bwException.WriteErrors), 10, "expected 10 writeErrors, got %v", len(bwException.WriteErrors)) for _, writeErr := range bwException.WriteErrors { switch writeErr.Request.(type) { case mongo.DeleteOneModel: assert.True(mt, writeErr.Index == 0 \|\| writeErr.Index == 6, "expected index 0 or 6, got %v", writeErr.Index) case mongo.DeleteManyModel: assert.True(mt, writeErr.Index == 1 \|\| writeErr.Index == 4, "expected index 1 or 4, got %v", writeErr.Index) case mongo.UpdateManyModel: assert.True(mt, writeErr.Index == 5 \|\| writeErr.Index == 9, "expected index 5 or 9, got %v", writeErr.Index) case mongo.InsertOneModel: assert.True(mt, writeErr.Index == 3 \|\| writeErr.Index == 7, "expected index 3 or 7, got %v", writeErr.Index) case mongo.UpdateOneModel: assert.Equal(mt, writeErr.Index, 2, "expected index 2, got %v", writeErr.Index) case mongo.ReplaceOneModel: assert.Equal(mt, writeErr.Index, 8, "expected index 8, got %v", writeErr.Index) } } }) mt.Run("unordered upsertID index", func(mt mtest.T) { id1 := "id1" id3 := "id3" models := []mongo.WriteModel{ mongo.NewDeleteOneModel().SetFilter(bson.D{{"_id", "id0"}}), mongo.NewReplaceOneModel().SetFilter(bson.D{{"_id", id1}}).SetReplacement(bson.D{{"_id", id1}}).SetUpsert(true), mongo.NewDeleteOneModel().SetFilter(bson.D{{"_id", "id2"}}), mongo.NewReplaceOneModel().SetFilter(bson.D{{"_id", id3}}).SetReplacement(bson.D{{"_id", id3}}).SetUpsert(true), mongo.NewDeleteOneModel().SetFilter(bson.D{{"_id", "id4"}}), } res, err := mt.Coll.BulkWrite(context.Background(), models, options.BulkWrite().SetOrdered(false)) assert.Nil(mt, err, "bulkwrite error: %v", err) assert.Equal(mt, len(res.UpsertedIDs), 2, "expected 2 UpsertedIDs, got %v", len(res.UpsertedIDs)) assert.Equal(mt, res.UpsertedIDs[1].(string), id1, "expected UpsertedIDs[1] to be %v, got %v", id1, res.UpsertedIDs[1]) assert.Equal(mt, res.UpsertedIDs[3].(string), id3, "expected UpsertedIDs[3] to be %v, got %v", id3, res.UpsertedIDs[3]) }) unackClientOpts := options.Client(). SetWriteConcern(writeconcern.New(writeconcern.W(0))) unackMtOpts := mtest.NewOptions(). ClientOptions(unackClientOpts). MinServerVersion("3.6") mt.RunOpts("unacknowledged write", unackMtOpts, func(mt mtest.T) { models := []mongo.WriteModel{ mongo.NewInsertOneModel().SetDocument(bson.D{{"x", 1}}), } _, err := mt.Coll.BulkWrite(context.Background(), models) if !errors.Is(err, mongo.ErrUnacknowledgedWrite) { // Use a direct comparison rather than assert.Equal because assert.Equal will compare the error strings, // so the assertion would succeed even if the error had not been wrapped. mt.Fatalf("expected BulkWrite error %v, got %v", mongo.ErrUnacknowledgedWrite, err) } }) mt.RunOpts("insert and delete with batches", mtest.NewOptions().ClientType(mtest.Mock), func(mt mtest.T) { // grouped together because delete requires the documents to be inserted maxBatchCount := int(mtest.MockDescription.MaxBatchCount) numDocs := maxBatchCount + 50 var insertModels []mongo.WriteModel var deleteModels []mongo.WriteModel for i := 0; i < numDocs; i++ { d := bson.D{ {"a", int32(i)}, {"b", int32(i 2)}, {"c", int32(i * 3)}, } insertModels = append(insertModels, mongo.NewInsertOneModel().SetDocument(d)) deleteModels = append(deleteModels, mongo.NewDeleteOneModel().SetFilter(bson.D{})) } // Seed mock responses. Both insert and delete responses look like {ok: 1, n: <inserted/deleted count>}. // This loop only creates one set of responses, but the sets for insert and delete should be equivalent, // so we can duplicate the generated set before calling mt.AddMockResponses(). var responses []bson.D for i := numDocs; i > 0; i -= maxBatchCount { count := maxBatchCount if i < maxBatchCount { count = i } res := mtest.CreateSuccessResponse(bson.E{"n", count}) responses = append(responses, res) } mt.AddMockResponses(append(responses, responses...)...) mt.ClearEvents() res, err := mt.Coll.BulkWrite(context.Background(), insertModels) assert.Nil(mt, err, "BulkWrite error: %v", err) assert.Equal(mt, int64(numDocs), res.InsertedCount, "expected %v inserted documents, got %v", numDocs, res.InsertedCount) mt.FilterStartedEvents(func(evt event.CommandStartedEvent) bool { return evt.CommandName == "insert" }) // MaxWriteBatchSize changed between 3.4 and 3.6, so there isn't a given number of batches that this will be split into inserts := len(mt.GetAllStartedEvents()) assert.True(mt, inserts > 1, "expected multiple batches, got %v", inserts) mt.ClearEvents() res, err = mt.Coll.BulkWrite(context.Background(), deleteModels) assert.Nil(mt, err, "BulkWrite error: %v", err) assert.Equal(mt, int64(numDocs), res.DeletedCount, "expected %v deleted documents, got %v", numDocs, res.DeletedCount) mt.FilterStartedEvents(func(evt event.CommandStartedEvent) bool { return evt.CommandName == "delete" }) // MaxWriteBatchSize changed between 3.4 and 3.6, so there isn't a given number of batches that this will be split into deletes := len(mt.GetAllStartedEvents()) assert.True(mt, deletes > 1, "expected multiple batches, got %v", deletes) }) mt.RunOpts("update with batches", mtest.NewOptions().ClientType(mtest.Mock), func(mt mtest.T) { maxBatchCount := int(mtest.MockDescription.MaxBatchCount) numModels := maxBatchCount + 50 var models []mongo.WriteModel // It's significantly faster to upsert the first model and only modify the rest than to upsert all of them. for i := 0; i < numModels-1; i++ { update := bson.D{ {"$set", bson.D{ {"a", int32(i + 1)}, {"b", int32(i 2)}, {"c", int32(i * 3)}, }}, } model := mongo.NewUpdateOneModel(). SetFilter(bson.D{{"a", int32(i)}}). SetUpdate(update).SetUpsert(true) models = append(models, model) } // Add one last upsert for second batch. models = append(models, mongo.NewUpdateOneModel(). SetFilter(bson.D{{"x", int32(1)}}). SetUpdate(bson.D{{"$set", bson.D{{"x", int32(1)}}}}). SetUpsert(true), ) // Seed mock responses for the BulkWrite. // // The response from the first batch should look like: // {ok: 1, n: 100000, nModified: 99999, upserted: [{index: 0, _id: <id>}]} firstBatchUpserted := bson.A{bson.D{{"index", 0}, {"_id", primitive.NewObjectID()}}} firstBatchResponse := mtest.CreateSuccessResponse( bson.E{"n", 100000}, bson.E{"nModified", 99999}, bson.E{"upserted", firstBatchUpserted}, ) // The response from the second batch should look like: // {ok: 1, n: 50, nModified: 49, upserted: [{index: 49, _id: <id>}]} secondBatchUpserted := bson.A{bson.D{{"index", 49}, {"_id", primitive.NewObjectID()}}} secondBatchResponse := mtest.CreateSuccessResponse( bson.E{"n", 50}, bson.E{"nModified", 49}, bson.E{"upserted", secondBatchUpserted}, ) mt.AddMockResponses([]primitive.D{firstBatchResponse, secondBatchResponse}...) mt.ClearEvents() res, err := mt.Coll.BulkWrite(context.Background(), models) assert.Nil(mt, err, "BulkWrite error: %v", err) mt.FilterStartedEvents(func(evt event.CommandStartedEvent) bool { return evt.CommandName == "update" }) // MaxWriteBatchSize changed between 3.4 and 3.6, so there isn't a given number of batches that // this will be split into. updates := len(mt.GetAllStartedEvents()) assert.True(mt, updates > 1, "expected multiple batches, got %v", updates) assert.Equal(mt, int64(numModels-2), res.ModifiedCount, "expected %v modified documents, got %v", numModels-2, res.ModifiedCount) assert.Equal(mt, int64(numModels-2), res.MatchedCount, "expected %v matched documents, got %v", numModels-2, res.ModifiedCount) assert.Equal(mt, int64(2), res.UpsertedCount, "expected %v upserted documents, got %v", 2, res.UpsertedCount) assert.Equal(mt, 2, len(res.UpsertedIDs), "expected %v upserted ids, got %v", 2, len(res.UpsertedIDs)) // Check that IDs exist in result for upserted documents. _, ok := res.UpsertedIDs[0] assert.True(mt, ok, "expected id at key 0") _, ok = res.UpsertedIDs[int64(numModels-1)] assert.True(mt, ok, "expected id at key %v", numModels-1) }) mt.RunOpts("map hint", noClientOpts, func(mt mtest.T) { filter := bson.D{{"_id", "foo"}} testCases := []struct { name string models []mongo.WriteModel errParam string }{ {"updateOne/multi key", []mongo.WriteModel{mongo.NewUpdateOneModel().SetFilter(filter).SetUpdate(bson.D{{"$set", bson.D{{"x", "fa"}}}}).SetHint(bson.M{"_id": 1, "x": 1})}, "hint"}, {"updateMany/multi key", []mongo.WriteModel{mongo.NewUpdateManyModel().SetFilter(filter).SetUpdate(bson.D{{"$set", bson.D{{"x", "fa"}}}}).SetHint(bson.M{"_id": 1, "x": 1})}, "hint"}, {"replaceOne/multi key", []mongo.WriteModel{mongo.NewReplaceOneModel().SetFilter(filter).SetReplacement(bson.D{{"x", "bar"}}).SetHint(bson.M{"_id": 1, "x": 1})}, "hint"}, {"deleteOne/multi key", []mongo.WriteModel{mongo.NewDeleteOneModel().SetFilter(filter).SetHint(bson.M{"_id": 1, "x": 1})}, "hint"}, {"deleteMany/multi key", []mongo.WriteModel{mongo.NewDeleteManyModel().SetFilter(filter).SetHint(bson.M{"_id": 1, "x": 1})}, "hint"}, {"updateOne/one key", []mongo.WriteModel{mongo.NewUpdateOneModel().SetFilter(filter).SetUpdate(bson.D{{"$set", bson.D{{"x", "fa"}}}}).SetHint(bson.M{"_id": 1})}, ""}, {"updateMany/one key", []mongo.WriteModel{mongo.NewUpdateManyModel().SetFilter(filter).SetUpdate(bson.D{{"$set", bson.D{{"x", "fa"}}}}).SetHint(bson.M{"_id": 1})}, ""}, {"replaceOne/one key", []mongo.WriteModel{mongo.NewReplaceOneModel().SetFilter(filter).SetReplacement(bson.D{{"x", "bar"}}).SetHint(bson.M{"_id": 1})}, ""}, {"deleteOne/one key", []mongo.WriteModel{mongo.NewDeleteOneModel().SetFilter(filter).SetHint(bson.M{"_id": 1})}, ""}, {"deleteMany/one key", []mongo.WriteModel{mongo.NewDeleteManyModel().SetFilter(filter).SetHint(bson.M{"_id": 1})}, ""}, } for _, tc := range testCases { mt.RunOpts(tc.name, mtest.NewOptions().MinServerVersion("4.4"), func(mt mtest.T) { _, err := mt.Coll.InsertOne(context.Background(), filter) assert.Nil(mt, err, "InsertOne error: %v", err) _, err = mt.Coll.BulkWrite(context.Background(), tc.models) if tc.errParam == "" { assert.Nil(mt, err, "expected nil error, got %v", err) return } expErr := mongo.ErrMapForOrderedArgument{tc.errParam} assert.Equal(mt, expErr, err, "expected error %v, got %v", expErr, err) }) } }) }) } func initCollection(mt mtest.T, coll mongo.Collection) { mt.Helper() var docs []interface{} for i := 1; i <= 5; i++ { docs = append(docs, bson.D{{"x", int32(i)}}) } _, err := coll.InsertMany(context.Background(), docs) assert.Nil(mt, err, "InsertMany error for initial data: %v", err) } func testAggregateWithOptions(mt mtest.T, createIndex bool, opts options.AggregateOptions) { mt.Helper() initCollection(mt, mt.Coll) if createIndex { indexView := mt.Coll.Indexes() _, err := indexView.CreateOne(context.Background(), mongo.IndexModel{ Keys: bson.D{{"x", 1}}, }) assert.Nil(mt, err, "CreateOne error: %v", err) } pipeline := mongo.Pipeline{ {{"$match", bson.D{{"x", bson.D{{"$gte", 2}}}}}}, {{"$project", bson.D{{"_id", 0}, {"x", 1}}}}, {{"$sort", bson.D{{"x", 1}}}}, } cursor, err := mt.Coll.Aggregate(context.Background(), pipeline, opts) assert.Nil(mt, err, "Aggregate error: %v", err) for i := 2; i < 5; i++ { assert.True(mt, cursor.Next(context.Background()), "expected Next true, got false") elems, _ := cursor.Current.Elements() assert.Equal(mt, 1, len(elems), "expected doc with 1 element, got %v", cursor.Current) num, err := cursor.Current.LookupErr("x") assert.Nil(mt, err, "x not found in document %v", cursor.Current) assert.Equal(mt, bson.TypeInt32, num.Type, "expected 'x' type %v, got %v", bson.TypeInt32, num.Type) assert.Equal(mt, int32(i), num.Int32(), "expected x value %v, got %v", i, num.Int32()) } } func create16MBDocument(mt mtest.T) bsoncore.Document { // 4 bytes = document length // 1 byte = element type (ObjectID = \x07) // 4 bytes = key name ("_id" + \x00) // 12 bytes = ObjectID value // 1 byte = element type (string = \x02) // 4 bytes = key name ("key" + \x00) // 4 bytes = string length // X bytes = string of length X bytes // 1 byte = \x00 // 1 byte = \x00 // // Therefore the string length should be: 1024102416 - 32 targetDocSize := 1024 * 1024 * 16 strSize := targetDocSize - 32 var b strings.Builder b.Grow(strSize) for i := 0; i < strSize; i++ { b.WriteByte('A') } idx, doc := bsoncore.AppendDocumentStart(nil) doc = bsoncore.AppendObjectIDElement(doc, "_id", primitive.NewObjectID()) doc = bsoncore.AppendStringElement(doc, "key", b.String()) doc, _ = bsoncore.AppendDocumentEnd(doc, idx) assert.Equal(mt, targetDocSize, len(doc), "expected document length %v, got %v", targetDocSize, len(doc)) return doc } // This is a helper function to ensure that sending getMore commands for a cursor results in command monitoring events // being published. The cursorFn parameter should be a function that yields a cursor which is open on the server and // requires at least one getMore to be fully iterated. func assertGetMoreCommandsAreMonitored(mt mtest.T, cmdName string, cursorFn func() (mongo.Cursor, error)) { mt.Helper() mt.ClearEvents() cursor, err := cursorFn() assert.Nil(mt, err, "error creating cursor: %v", err) var docs []bson.D err = cursor.All(context.Background(), &docs) assert.Nil(mt, err, "All error: %v", err) // Only assert that the initial command and at least one getMore were sent. The exact number of getMore's required // is not important. evt := mt.GetStartedEvent() assert.Equal(mt, cmdName, evt.CommandName, "expected command %q, got %q", cmdName, evt.CommandName) evt = mt.GetStartedEvent() assert.Equal(mt, "getMore", evt.CommandName, "expected command 'getMore', got %q", evt.CommandName) } // This is a helper function to ensure that sending killCursors commands for a cursor results in command monitoring // events being published. The cursorFn parameter should be a function that yields a cursor which is open on the server. func assertKillCursorsCommandsAreMonitored(mt mtest.T, cmdName string, cursorFn func() (mongo.Cursor, error)) { mt.Helper() mt.ClearEvents() cursor, err := cursorFn() assert.Nil(mt, err, "error creating cursor: %v", err) err = cursor.Close(context.Background()) assert.Nil(mt, err, "Close error: %v", err) evt := mt.GetStartedEvent() assert.Equal(mt, cmdName, evt.CommandName, "expected command %q, got %q", cmdName, evt.CommandName) evt = mt.GetStartedEvent() assert.Equal(mt, "killCursors", evt.CommandName, "expected command 'killCursors', got %q", evt.CommandName) }	85.82 KB	2025-05-25 12:27
📄 crud_helpers_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "bytes" "context" "fmt" "math" "strconv" "strings" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/bsonutil" "go.mongodb.org/mongo-driver/internal/integtest" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/gridfs" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/integration/unified" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/mongo/readconcern" "go.mongodb.org/mongo-driver/mongo/readpref" ) // Helper functions to execute and verify results from CRUD methods. var ( emptyDoc = []byte{5, 0, 0, 0, 0} errorCommandNotFound int32 = 59 errorLockTimeout int32 = 24 errorCommandNotSupported int32 = 115 killAllSessionsErrorCodes = map[int32]struct{}{ errorInterrupted: {}, // the command interrupts itself errorCommandNotFound: {}, // the killAllSessions command does not exist on server versions < 3.6 errorCommandNotSupported: {}, // the command is not supported on Atlas Data Lake } ) // create an update document or pipeline from a bson.RawValue func createUpdate(mt mtest.T, updateVal bson.RawValue) interface{} { switch updateVal.Type { case bson.TypeEmbeddedDocument: return updateVal.Document() case bson.TypeArray: var updateDocs []bson.Raw docs, _ := updateVal.Array().Values() for _, doc := range docs { updateDocs = append(updateDocs, doc.Document()) } return updateDocs default: mt.Fatalf("unrecognized update type: %v", updateVal.Type) } return nil } // create a hint string or document from a bson.RawValue func createHint(mt mtest.T, val bson.RawValue) interface{} { mt.Helper() var hint interface{} switch val.Type { case bsontype.String: hint = val.StringValue() case bsontype.EmbeddedDocument: hint = val.Document() default: mt.Fatalf("unrecognized hint value type: %s\n", val.Type) } return hint } // returns true if err is a mongo.CommandError containing a code that is expected from a killAllSessions command. func isExpectedKillAllSessionsError(err error) bool { cmdErr, ok := err.(mongo.CommandError) if !ok { return false } _, ok = killAllSessionsErrorCodes[cmdErr.Code] // for SERVER-54216 on atlas atlasUnauthorized := strings.Contains(err.Error(), "(AtlasError) (Unauthorized)") return ok \|\| atlasUnauthorized } // kill all open sessions on the server. This function uses mt.GlobalClient() because killAllSessions is not allowed // for clients configured with specific options (e.g. client side encryption). func killSessions(mt mtest.T) { mt.Helper() cmd := bson.D{ {"killAllSessions", bson.A{}}, } runCmdOpts := options.RunCmd().SetReadPreference(mtest.PrimaryRp) // killAllSessions has to be run against each mongos in a sharded cluster, so we use the runCommandOnAllServers // helper. err := runCommandOnAllServers(func(client mongo.Client) error { return client.Database("admin").RunCommand(context.Background(), cmd, runCmdOpts).Err() }) if err == nil { return } if !isExpectedKillAllSessionsError(err) { mt.Fatalf("killAllSessions error: %v", err) } } // Utility function to run a command on all servers. For standalones, the command is run against the one server. For // replica sets, the command is run against the primary. sharded clusters, the command is run against each mongos. func runCommandOnAllServers(commandFn func(client mongo.Client) error) error { opts := options.Client().ApplyURI(mtest.ClusterURI()) integtest.AddTestServerAPIVersion(opts) if mtest.ClusterTopologyKind() != mtest.Sharded { client, err := mongo.Connect(context.Background(), opts) if err != nil { return fmt.Errorf("error creating replica set client: %w", err) } defer func() { _ = client.Disconnect(context.Background()) }() return commandFn(client) } for _, host := range opts.Hosts { shardClient, err := mongo.Connect(context.Background(), opts.SetHosts([]string{host})) if err != nil { return fmt.Errorf("error creating client for mongos %v: %w", host, err) } err = commandFn(shardClient) _ = shardClient.Disconnect(context.Background()) if err != nil { return err } } return nil } // aggregator is an interface used to run collection and database-level aggregations type aggregator interface { Aggregate(context.Context, interface{}, ...options.AggregateOptions) (mongo.Cursor, error) } // watcher is an interface used to create client, db, and collection-level change streams type watcher interface { Watch(context.Context, interface{}, ...options.ChangeStreamOptions) (mongo.ChangeStream, error) } func executeAggregate(mt mtest.T, agg aggregator, sess mongo.Session, args bson.Raw) (mongo.Cursor, error) { mt.Helper() var pipeline []interface{} opts := options.Aggregate() elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "pipeline": pipeline = bsonutil.RawToInterfaces(bsonutil.RawToDocuments(val.Array())...) case "batchSize": opts.SetBatchSize(val.Int32()) case "collation": opts.SetCollation(createCollation(mt, val.Document())) case "maxTimeMS": opts.SetMaxTime(time.Duration(val.Int32()) time.Millisecond) case "allowDiskUse": opts.SetAllowDiskUse(val.Boolean()) case "session": default: mt.Fatalf("unrecognized aggregate option: %v", key) } } if sess != nil { var cur mongo.Cursor err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var aerr error cur, aerr = agg.Aggregate(sc, pipeline, opts) return aerr }) return cur, err } return agg.Aggregate(context.Background(), pipeline, opts) } func executeWatch(mt mtest.T, w watcher, sess mongo.Session, args bson.Raw) (mongo.ChangeStream, error) { mt.Helper() pipeline := []interface{}{} elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "pipeline": pipeline = bsonutil.RawToInterfaces(bsonutil.RawToDocuments(val.Array())...) default: mt.Fatalf("unrecognized watch option: %v", key) } } if sess != nil { var stream mongo.ChangeStream err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var csErr error stream, csErr = w.Watch(sc, pipeline) return csErr }) return stream, err } return w.Watch(context.Background(), pipeline) } func executeCountDocuments(mt mtest.T, sess mongo.Session, args bson.Raw) (int64, error) { mt.Helper() filter := emptyDoc opts := options.Count() elems, _ := args.Elements() for _, elem := range elems { name := elem.Key() opt := elem.Value() switch name { case "filter": filter = opt.Document() case "skip": opts = opts.SetSkip(int64(opt.Int32())) case "limit": opts = opts.SetLimit(int64(opt.Int32())) case "collation": opts = opts.SetCollation(createCollation(mt, opt.Document())) case "session": default: mt.Fatalf("unrecognized count option: %v", name) } } if sess != nil { var count int64 err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var countErr error count, countErr = mt.Coll.CountDocuments(sc, filter, opts) return countErr }) return count, err } return mt.Coll.CountDocuments(context.Background(), filter, opts) } func executeInsertOne(mt mtest.T, sess mongo.Session, args bson.Raw) (mongo.InsertOneResult, error) { mt.Helper() doc := emptyDoc opts := options.InsertOne() elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "document": doc = val.Document() case "bypassDocumentValidation": opts.SetBypassDocumentValidation(val.Boolean()) case "session": default: mt.Fatalf("unrecognized insertOne option: %v", key) } } if sess != nil { var res mongo.InsertOneResult err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var insertErr error res, insertErr = mt.Coll.InsertOne(sc, doc, opts) return insertErr }) return res, err } return mt.Coll.InsertOne(context.Background(), doc, opts) } func executeInsertMany(mt mtest.T, sess mongo.Session, args bson.Raw) (mongo.InsertManyResult, error) { mt.Helper() var docs []interface{} opts := options.InsertMany() elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "documents": docs = bsonutil.RawToInterfaces(bsonutil.RawToDocuments(val.Array())...) case "options": // Some of the older tests use this to set the "ordered" option optsDoc := val.Document() optsElems, _ := optsDoc.Elements() assert.Equal(mt, 1, len(optsElems), "expected 1 options element, got %v", len(optsElems)) opts.SetOrdered(optsDoc.Lookup("ordered").Boolean()) case "session": default: mt.Fatalf("unrecognized insertMany option: %v", key) } } if sess != nil { var res mongo.InsertManyResult err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var insertErr error res, insertErr = mt.Coll.InsertMany(sc, docs, opts) return insertErr }) return res, err } return mt.Coll.InsertMany(context.Background(), docs, opts) } func setFindModifiers(modifiersDoc bson.Raw, opts options.FindOptions) { elems, _ := modifiersDoc.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "$comment": opts.SetComment(val.StringValue()) case "$hint": opts.SetHint(val.Document()) case "$max": opts.SetMax(val.Document()) case "$maxTimeMS": opts.SetMaxTime(time.Duration(val.Int32()) * time.Millisecond) case "$min": opts.SetMin(val.Document()) case "$returnKey": opts.SetReturnKey(val.Boolean()) case "$showDiskLoc": opts.SetShowRecordID(val.Boolean()) } } } func executeFind(mt mtest.T, sess mongo.Session, args bson.Raw) (mongo.Cursor, error) { mt.Helper() filter := emptyDoc opts := options.Find() elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "filter": filter = val.Document() case "sort": opts = opts.SetSort(val.Document()) case "skip": opts = opts.SetSkip(numberFromValue(mt, val)) case "limit": opts = opts.SetLimit(numberFromValue(mt, val)) case "batchSize": opts = opts.SetBatchSize(int32(numberFromValue(mt, val))) case "collation": opts = opts.SetCollation(createCollation(mt, val.Document())) case "modifiers": setFindModifiers(val.Document(), opts) case "allowDiskUse": opts = opts.SetAllowDiskUse(val.Boolean()) case "projection": opts = opts.SetProjection(val.Document()) case "session": default: mt.Fatalf("unrecognized find option: %v", key) } } if sess != nil { var c mongo.Cursor err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var findErr error c, findErr = mt.Coll.Find(sc, filter, opts) return findErr }) return c, err } return mt.Coll.Find(context.Background(), filter, opts) } func executeRunCommand(mt mtest.T, sess mongo.Session, args bson.Raw) mongo.SingleResult { mt.Helper() cmd := emptyDoc opts := options.RunCmd() elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "command": cmd = val.Document() case "readPreference": opts.SetReadPreference(createReadPref(val)) case "session": default: mt.Fatalf("unrecognized runCommand option: %v", key) } } if sess != nil { var sr mongo.SingleResult _ = mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { sr = mt.DB.RunCommand(sc, cmd, opts) return nil }) return sr } return mt.DB.RunCommand(context.Background(), cmd, opts) } func executeListCollections(mt mtest.T, sess mongo.Session, args bson.Raw) (mongo.Cursor, error) { mt.Helper() filter := emptyDoc elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "filter": filter = val.Document() default: mt.Fatalf("unrecognized listCollectionNames option: %v", key) } } if sess != nil { var c mongo.Cursor err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var lcErr error c, lcErr = mt.DB.ListCollections(sc, filter) return lcErr }) return c, err } return mt.DB.ListCollections(context.Background(), filter) } func executeListCollectionNames(mt mtest.T, sess mongo.Session, args bson.Raw) ([]string, error) { mt.Helper() filter := emptyDoc elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "filter": filter = val.Document() default: mt.Fatalf("unrecognized listCollectionNames option: %v", key) } } if sess != nil { var res []string err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var lcErr error res, lcErr = mt.DB.ListCollectionNames(sc, filter) return lcErr }) return res, err } return mt.DB.ListCollectionNames(context.Background(), filter) } func executeListDatabaseNames(mt mtest.T, sess mongo.Session, args bson.Raw) ([]string, error) { mt.Helper() filter := emptyDoc elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "filter": filter = val.Document() default: mt.Fatalf("unrecognized listCollectionNames option: %v", key) } } if sess != nil { var res []string err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var ldErr error res, ldErr = mt.Client.ListDatabaseNames(sc, filter) return ldErr }) return res, err } return mt.Client.ListDatabaseNames(context.Background(), filter) } func executeListDatabases(mt mtest.T, sess mongo.Session, args bson.Raw) (mongo.ListDatabasesResult, error) { mt.Helper() filter := emptyDoc elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "filter": filter = val.Document() default: mt.Fatalf("unrecognized listCollectionNames option: %v", key) } } if sess != nil { var res mongo.ListDatabasesResult err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var ldErr error res, ldErr = mt.Client.ListDatabases(sc, filter) return ldErr }) return res, err } return mt.Client.ListDatabases(context.Background(), filter) } func executeFindOne(mt mtest.T, sess mongo.Session, args bson.Raw) mongo.SingleResult { mt.Helper() filter := emptyDoc elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "filter": filter = val.Document() default: mt.Fatalf("unrecognized findOne option: %v", key) } } if sess != nil { var res mongo.SingleResult _ = mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { res = mt.Coll.FindOne(sc, filter) return nil }) return res } return mt.Coll.FindOne(context.Background(), filter) } func executeListIndexes(mt mtest.T, sess mongo.Session, args bson.Raw) (mongo.Cursor, error) { mt.Helper() // no arguments expected. add a Fatal in case arguments are added in the future assert.Equal(mt, 0, len(args), "unexpected listIndexes arguments: %v", args) if sess != nil { var cursor mongo.Cursor err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var listErr error cursor, listErr = mt.Coll.Indexes().List(sc) return listErr }) return cursor, err } return mt.Coll.Indexes().List(context.Background()) } func executeDistinct(mt mtest.T, sess mongo.Session, args bson.Raw) ([]interface{}, error) { mt.Helper() var fieldName string filter := emptyDoc opts := options.Distinct() elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "filter": filter = val.Document() case "fieldName": fieldName = val.StringValue() case "collation": opts = opts.SetCollation(createCollation(mt, val.Document())) case "session": default: mt.Fatalf("unrecognized distinct option: %v", key) } } if sess != nil { var res []interface{} err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var derr error res, derr = mt.Coll.Distinct(sc, fieldName, filter, opts) return derr }) return res, err } return mt.Coll.Distinct(context.Background(), fieldName, filter, opts) } func executeFindOneAndDelete(mt mtest.T, sess mongo.Session, args bson.Raw) mongo.SingleResult { mt.Helper() filter := emptyDoc opts := options.FindOneAndDelete() elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "filter": filter = val.Document() case "sort": opts = opts.SetSort(val.Document()) case "projection": opts = opts.SetProjection(val.Document()) case "collation": opts = opts.SetCollation(createCollation(mt, val.Document())) case "hint": opts = opts.SetHint(createHint(mt, val)) case "session": default: mt.Fatalf("unrecognized findOneAndDelete option: %v", key) } } if sess != nil { var res mongo.SingleResult _ = mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { res = mt.Coll.FindOneAndDelete(sc, filter, opts) return nil }) return res } return mt.Coll.FindOneAndDelete(context.Background(), filter, opts) } func executeFindOneAndUpdate(mt mtest.T, sess mongo.Session, args bson.Raw) mongo.SingleResult { mt.Helper() filter := emptyDoc var update interface{} = emptyDoc opts := options.FindOneAndUpdate() elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "filter": filter = val.Document() case "update": update = createUpdate(mt, val) case "arrayFilters": opts = opts.SetArrayFilters(options.ArrayFilters{ Filters: bsonutil.RawToInterfaces(bsonutil.RawToDocuments(val.Array())...), }) case "sort": opts = opts.SetSort(val.Document()) case "projection": opts = opts.SetProjection(val.Document()) case "upsert": opts = opts.SetUpsert(val.Boolean()) case "returnDocument": switch vstr := val.StringValue(); vstr { case "After": opts = opts.SetReturnDocument(options.After) case "Before": opts = opts.SetReturnDocument(options.Before) default: mt.Fatalf("unrecognized returnDocument value: %v", vstr) } case "collation": opts = opts.SetCollation(createCollation(mt, val.Document())) case "hint": opts = opts.SetHint(createHint(mt, val)) case "session": default: mt.Fatalf("unrecognized findOneAndUpdate option: %v", key) } } if sess != nil { var res mongo.SingleResult _ = mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { res = mt.Coll.FindOneAndUpdate(sc, filter, update, opts) return nil }) return res } return mt.Coll.FindOneAndUpdate(context.Background(), filter, update, opts) } func executeFindOneAndReplace(mt mtest.T, sess mongo.Session, args bson.Raw) mongo.SingleResult { mt.Helper() filter := emptyDoc replacement := emptyDoc opts := options.FindOneAndReplace() elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "filter": filter = val.Document() case "replacement": replacement = val.Document() case "sort": opts = opts.SetSort(val.Document()) case "projection": opts = opts.SetProjection(val.Document()) case "upsert": opts = opts.SetUpsert(val.Boolean()) case "returnDocument": switch vstr := val.StringValue(); vstr { case "After": opts = opts.SetReturnDocument(options.After) case "Before": opts = opts.SetReturnDocument(options.Before) default: mt.Fatalf("unrecognized returnDocument value: %v", vstr) } case "collation": opts = opts.SetCollation(createCollation(mt, val.Document())) case "hint": opts = opts.SetHint(createHint(mt, val)) case "session": default: mt.Fatalf("unrecognized findOneAndReplace option: %v", key) } } if sess != nil { var res mongo.SingleResult _ = mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { res = mt.Coll.FindOneAndReplace(sc, filter, replacement, opts) return nil }) return res } return mt.Coll.FindOneAndReplace(context.Background(), filter, replacement, opts) } func executeDeleteOne(mt mtest.T, sess mongo.Session, args bson.Raw) (mongo.DeleteResult, error) { mt.Helper() filter := emptyDoc opts := options.Delete() elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "filter": filter = val.Document() case "collation": opts = opts.SetCollation(createCollation(mt, val.Document())) case "hint": opts = opts.SetHint(createHint(mt, val)) case "session": default: mt.Fatalf("unrecognized deleteOne option: %v", key) } } if sess != nil { var res mongo.DeleteResult err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var derr error res, derr = mt.Coll.DeleteOne(sc, filter, opts) return derr }) return res, err } return mt.Coll.DeleteOne(context.Background(), filter, opts) } func executeDeleteMany(mt mtest.T, sess mongo.Session, args bson.Raw) (mongo.DeleteResult, error) { mt.Helper() filter := emptyDoc opts := options.Delete() elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "filter": filter = val.Document() case "collation": opts = opts.SetCollation(createCollation(mt, val.Document())) case "hint": opts = opts.SetHint(createHint(mt, val)) case "session": default: mt.Fatalf("unrecognized deleteMany option: %v", key) } } if sess != nil { var res mongo.DeleteResult err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var derr error res, derr = mt.Coll.DeleteMany(sc, filter, opts) return derr }) return res, err } return mt.Coll.DeleteMany(context.Background(), filter, opts) } func executeUpdateOne(mt mtest.T, sess mongo.Session, args bson.Raw) (mongo.UpdateResult, error) { mt.Helper() filter := emptyDoc var update interface{} = emptyDoc opts := options.Update() elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "filter": filter = val.Document() case "update": update = createUpdate(mt, val) case "arrayFilters": opts = opts.SetArrayFilters(options.ArrayFilters{ Filters: bsonutil.RawToInterfaces(bsonutil.RawToDocuments(val.Array())...), }) case "upsert": opts = opts.SetUpsert(val.Boolean()) case "collation": opts = opts.SetCollation(createCollation(mt, val.Document())) case "hint": opts = opts.SetHint(createHint(mt, val)) case "session": default: mt.Fatalf("unrecognized updateOne option: %v", key) } } if opts.Upsert == nil { opts = opts.SetUpsert(false) } if sess != nil { var res mongo.UpdateResult err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var uerr error res, uerr = mt.Coll.UpdateOne(sc, filter, update, opts) return uerr }) return res, err } return mt.Coll.UpdateOne(context.Background(), filter, update, opts) } func executeUpdateMany(mt mtest.T, sess mongo.Session, args bson.Raw) (mongo.UpdateResult, error) { mt.Helper() filter := emptyDoc var update interface{} = emptyDoc opts := options.Update() elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "filter": filter = val.Document() case "update": update = createUpdate(mt, val) case "arrayFilters": opts = opts.SetArrayFilters(options.ArrayFilters{ Filters: bsonutil.RawToInterfaces(bsonutil.RawToDocuments(val.Array())...), }) case "upsert": opts = opts.SetUpsert(val.Boolean()) case "collation": opts = opts.SetCollation(createCollation(mt, val.Document())) case "hint": opts = opts.SetHint(createHint(mt, val)) case "session": default: mt.Fatalf("unrecognized updateMany option: %v", key) } } if opts.Upsert == nil { opts = opts.SetUpsert(false) } if sess != nil { var res mongo.UpdateResult err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var uerr error res, uerr = mt.Coll.UpdateMany(sc, filter, update, opts) return uerr }) return res, err } return mt.Coll.UpdateMany(context.Background(), filter, update, opts) } func executeReplaceOne(mt mtest.T, sess mongo.Session, args bson.Raw) (mongo.UpdateResult, error) { mt.Helper() filter := emptyDoc replacement := emptyDoc opts := options.Replace() elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "filter": filter = val.Document() case "replacement": replacement = val.Document() case "upsert": opts = opts.SetUpsert(val.Boolean()) case "collation": opts = opts.SetCollation(createCollation(mt, val.Document())) case "hint": opts = opts.SetHint(createHint(mt, val)) case "session": default: mt.Fatalf("unrecognized replaceOne option: %v", key) } } if opts.Upsert == nil { opts = opts.SetUpsert(false) } if sess != nil { var res mongo.UpdateResult err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var uerr error res, uerr = mt.Coll.ReplaceOne(sc, filter, replacement, opts) return uerr }) return res, err } return mt.Coll.ReplaceOne(context.Background(), filter, replacement, opts) } type withTransactionArgs struct { Callback struct { Operations []operation `bson:"operations"` } `bson:"callback"` Options bson.Raw `bson:"options"` } func runWithTransactionOperations(mt mtest.T, operations []operation, sess mongo.Session) error { mt.Helper() for _, op := range operations { if op.Name == "count" { mt.Skip("count has been deprecated") } // create collection with default read preference Primary (needed to prevent server selection fail) mt.CloneCollection(options.Collection().SetReadPreference(readpref.Primary()).SetReadConcern(readconcern.Local())) // execute the command on given object var err error switch op.Object { case "session0": err = executeSessionOperation(mt, op, sess) case "collection": err = executeCollectionOperation(mt, op, sess) default: mt.Fatalf("unrecognized withTransaction operation object: %v", op.Object) } if err != nil { return err } } return nil } func executeWithTransaction(mt mtest.T, sess mongo.Session, args bson.Raw) error { mt.Helper() var testArgs withTransactionArgs err := bson.UnmarshalWithRegistry(specTestRegistry, args, &testArgs) assert.Nil(mt, err, "error creating withTransactionArgs: %v", err) opts := createTransactionOptions(mt, testArgs.Options) _, err = sess.WithTransaction(context.Background(), func(sc mongo.SessionContext) (interface{}, error) { err := runWithTransactionOperations(mt, testArgs.Callback.Operations, sess) return nil, err }, opts) return err } func executeBulkWrite(mt mtest.T, sess mongo.Session, args bson.Raw) (mongo.BulkWriteResult, error) { mt.Helper() models := createBulkWriteModels(mt, args.Lookup("requests").Array()) opts := options.BulkWrite() rawOpts, err := args.LookupErr("options") if err == nil { elems, _ := rawOpts.Document().Elements() for _, elem := range elems { name := elem.Key() opt := elem.Value() switch name { case "ordered": opts.SetOrdered(opt.Boolean()) default: mt.Fatalf("unrecognized bulk write option: %v", name) } } } if sess != nil { var res mongo.BulkWriteResult err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var bwerr error res, bwerr = mt.Coll.BulkWrite(sc, models, opts) return bwerr }) return res, err } return mt.Coll.BulkWrite(context.Background(), models, opts) } func createBulkWriteModels(mt mtest.T, rawModels bson.Raw) []mongo.WriteModel { vals, _ := rawModels.Values() models := make([]mongo.WriteModel, len(vals)) for i, val := range vals { models[i] = createBulkWriteModel(mt, val.Document()) } return models } func createBulkWriteModel(mt mtest.T, rawModel bson.Raw) mongo.WriteModel { name := rawModel.Lookup("name").StringValue() args := rawModel.Lookup("arguments").Document() switch name { case "insertOne": return mongo.NewInsertOneModel().SetDocument(args.Lookup("document").Document()) case "updateOne": uom := mongo.NewUpdateOneModel() uom.SetFilter(args.Lookup("filter").Document()) uom.SetUpdate(createUpdate(mt, args.Lookup("update"))) if upsert, err := args.LookupErr("upsert"); err == nil { uom.SetUpsert(upsert.Boolean()) } if collation, err := args.LookupErr("collation"); err == nil { uom.SetCollation(createCollation(mt, collation.Document())) } if arrayFilters, err := args.LookupErr("arrayFilters"); err == nil { uom.SetArrayFilters(options.ArrayFilters{ Filters: bsonutil.RawToInterfaces(bsonutil.RawToDocuments(arrayFilters.Array())...), }) } if hintVal, err := args.LookupErr("hint"); err == nil { uom.SetHint(createHint(mt, hintVal)) } if uom.Upsert == nil { uom.SetUpsert(false) } return uom case "updateMany": umm := mongo.NewUpdateManyModel() umm.SetFilter(args.Lookup("filter").Document()) umm.SetUpdate(createUpdate(mt, args.Lookup("update"))) if upsert, err := args.LookupErr("upsert"); err == nil { umm.SetUpsert(upsert.Boolean()) } if collation, err := args.LookupErr("collation"); err == nil { umm.SetCollation(createCollation(mt, collation.Document())) } if arrayFilters, err := args.LookupErr("arrayFilters"); err == nil { umm.SetArrayFilters(options.ArrayFilters{ Filters: bsonutil.RawToInterfaces(bsonutil.RawToDocuments(arrayFilters.Array())...), }) } if hintVal, err := args.LookupErr("hint"); err == nil { umm.SetHint(createHint(mt, hintVal)) } if umm.Upsert == nil { umm.SetUpsert(false) } return umm case "deleteOne": dom := mongo.NewDeleteOneModel() dom.SetFilter(args.Lookup("filter").Document()) if collation, err := args.LookupErr("collation"); err == nil { dom.SetCollation(createCollation(mt, collation.Document())) } if hint, err := args.LookupErr("hint"); err == nil { dom.SetHint(createHint(mt, hint)) } return dom case "deleteMany": dmm := mongo.NewDeleteManyModel() dmm.SetFilter(args.Lookup("filter").Document()) if collation, err := args.LookupErr("collation"); err == nil { dmm.SetCollation(createCollation(mt, collation.Document())) } if hint, err := args.LookupErr("hint"); err == nil { dmm.SetHint(createHint(mt, hint)) } return dmm case "replaceOne": rom := mongo.NewReplaceOneModel() rom.SetFilter(args.Lookup("filter").Document()) rom.SetReplacement(args.Lookup("replacement").Document()) if upsert, err := args.LookupErr("upsert"); err == nil { rom.SetUpsert(upsert.Boolean()) } if collation, err := args.LookupErr("collation"); err == nil { rom.SetCollation(createCollation(mt, collation.Document())) } if hintVal, err := args.LookupErr("hint"); err == nil { rom.SetHint(createHint(mt, hintVal)) } if rom.Upsert == nil { rom.SetUpsert(false) } return rom default: mt.Fatalf("unrecognized model type: %v", name) } return nil } func executeEstimatedDocumentCount(mt mtest.T, sess mongo.Session, args bson.Raw) (int64, error) { mt.Helper() // no arguments expected. add a Fatal in case arguments are added in the future elems, _ := args.Elements() assert.Equal(mt, 0, len(elems), "unexpected estimatedDocumentCount arguments %v", args) if sess != nil { var res int64 err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var countErr error res, countErr = mt.Coll.EstimatedDocumentCount(sc) return countErr }) return res, err } return mt.Coll.EstimatedDocumentCount(context.Background()) } func executeGridFSDownload(mt mtest.T, bucket gridfs.Bucket, args bson.Raw) (int64, error) { mt.Helper() var fileID primitive.ObjectID elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "id": fileID = val.ObjectID() default: mt.Fatalf("unrecognized download option: %v", key) } } return bucket.DownloadToStream(fileID, new(bytes.Buffer)) } func executeGridFSDownloadByName(mt mtest.T, bucket gridfs.Bucket, args bson.Raw) (int64, error) { mt.Helper() var file string elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "filename": file = val.StringValue() default: mt.Fatalf("unrecognized download by name option: %v", key) } } return bucket.DownloadToStreamByName(file, new(bytes.Buffer)) } func executeCreateIndex(mt mtest.T, sess mongo.Session, args bson.Raw) (string, error) { mt.Helper() model := mongo.IndexModel{ Options: options.Index(), } elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "keys": model.Keys = val.Document() case "name": model.Options.SetName(val.StringValue()) case "session": default: mt.Fatalf("unrecognized createIndex option %v", key) } } if sess != nil { var indexName string err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var indexErr error indexName, indexErr = mt.Coll.Indexes().CreateOne(sc, model) return indexErr }) return indexName, err } return mt.Coll.Indexes().CreateOne(context.Background(), model) } func executeDropIndex(mt mtest.T, sess mongo.Session, args bson.Raw) (bson.Raw, error) { mt.Helper() var name string elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "name": name = val.StringValue() default: mt.Fatalf("unrecognized dropIndex option %v", key) } } if sess != nil { var res bson.Raw err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { var indexErr error res, indexErr = mt.Coll.Indexes().DropOne(sc, name) return indexErr }) return res, err } return mt.Coll.Indexes().DropOne(context.Background(), name) } func executeDropCollection(mt mtest.T, sess mongo.Session, args bson.Raw) error { mt.Helper() var collName string elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "encryptedFields": mt.Fatalf("unsupported field: encryptedFields") case "collection": collName = val.StringValue() default: mt.Fatalf("unrecognized dropCollection option %v", key) } } coll := mt.DB.Collection(collName) if sess != nil { err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { return coll.Drop(sc) }) return err } return coll.Drop(context.Background()) } func executeCreateCollection(mt mtest.T, sess mongo.Session, args bson.Raw) error { mt.Helper() cco := options.CreateCollection() var collName string elems, _ := args.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "encryptedFields": cco.SetEncryptedFields(val.Document()) case "collection": collName = val.StringValue() case "validator": cco.SetValidator(val.Document()) case "session": default: mt.Fatalf("unrecognized createCollection option %v", key) } } if sess != nil { err := mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { return mt.DB.CreateCollection(sc, collName, cco) }) return err } return mt.DB.CreateCollection(context.Background(), collName, cco) } func executeAdminCommand(mt mtest.T, op operation) { // Per the streamable hello test format description, a separate client must be used to execute this operation. clientOpts := options.Client().ApplyURI(mtest.ClusterURI()) integtest.AddTestServerAPIVersion(clientOpts) client, err := mongo.Connect(context.Background(), clientOpts) assert.Nil(mt, err, "Connect error: %v", err) defer func() { _ = client.Disconnect(context.Background()) }() cmd := op.Arguments.Lookup("command").Document() if op.CommandName == "replSetStepDown" { // replSetStepDown can fail with transient errors, so we use executeAdminCommandWithRetry to handle them and // retry until a timeout is hit. executeAdminCommandWithRetry(mt, client, cmd) return } rco := options.RunCmd() rpVal, err := op.Arguments.LookupErr("readPreference") if err == nil { var temp unified.ReadPreference err = bson.Unmarshal(rpVal.Document(), &temp) assert.Nil(mt, err, "error unmarshalling readPreference option: %v", err) rp, err := temp.ToReadPrefOption() assert.Nil(mt, err, "error creating readpref.ReadPref object: %v", err) rco.SetReadPreference(rp) } db := client.Database("admin") err = db.RunCommand(context.Background(), cmd, rco).Err() assert.Nil(mt, err, "RunCommand error for command %q: %v", op.CommandName, err) } func executeAdminCommandWithRetry(mt mtest.T, client mongo.Client, cmd interface{}, opts ...options.RunCmdOptions) { mt.Helper() ctx, cancel := context.WithTimeout(context.Background(), 10time.Second) defer cancel() for { err := client.Database("admin").RunCommand(ctx, cmd, opts...).Err() if err == nil { return } if ce, ok := err.(mongo.CommandError); ok && ce.Code == errorLockTimeout { continue } mt.Fatalf("error executing command: %v", err) } } // verification function to use for all count operations func verifyCountResult(mt mtest.T, actualResult int64, expectedResult interface{}) { mt.Helper() if expectedResult == nil { return } expected := getIntFromInterface(expectedResult) assert.NotNil(mt, expected, "unexpected type for estimatedDocumentCount result: %T", expectedResult) assert.Equal(mt, expected, actualResult, "count mismatch; expected %v, got %v", expected, actualResult) } func verifyBulkWriteResult(mt mtest.T, actualResult mongo.BulkWriteResult, expectedResult interface{}) { mt.Helper() if expectedResult == nil { return } var expected struct { InsertedCount int64 `bson:"insertedCount"` MatchedCount int64 `bson:"matchedCount"` ModifiedCount int64 `bson:"modifiedCount"` DeletedCount int64 `bson:"deletedCount"` UpsertedCount int64 `bson:"upsertedCount"` UpsertedIDs map[string]interface{} `bson:"upsertedIds"` } err := bson.Unmarshal(expectedResult.(bson.Raw), &expected) assert.Nil(mt, err, "error creating BulkWriteResult: %v", err) assert.Equal(mt, expected.InsertedCount, actualResult.InsertedCount, "InsertedCount mismatch; expected %v, got %v", expected.InsertedCount, actualResult.InsertedCount) assert.Equal(mt, expected.MatchedCount, actualResult.MatchedCount, "MatchedCount mismatch; expected %v, got %v", expected.MatchedCount, actualResult.MatchedCount) assert.Equal(mt, expected.ModifiedCount, actualResult.ModifiedCount, "ModifiedCount mismatch; expected %v, got %v", expected.ModifiedCount, actualResult.ModifiedCount) assert.Equal(mt, expected.DeletedCount, actualResult.DeletedCount, "DeletedCount mismatch; expected %v, got %v", expected.DeletedCount, actualResult.DeletedCount) assert.Equal(mt, expected.UpsertedCount, actualResult.UpsertedCount, "UpsertedCount mismatch; expected %v, got %v", expected.UpsertedCount, actualResult.UpsertedCount) for idxStr, expectedID := range expected.UpsertedIDs { idx, err := strconv.Atoi(idxStr) assert.Nil(mt, err, "error converted index %v to int", idxStr) actualID, ok := actualResult.UpsertedIDs[int64(idx)] assert.True(mt, ok, "operation index %v not found in actual upserted IDs map", idx) assert.Equal(mt, expectedID, actualID, "upserted ID mismatch for key %v; expected %v, got %v", idx, expectedID, actualID) } } func verifyUpdateResult(mt mtest.T, res mongo.UpdateResult, result interface{}) { mt.Helper() if result == nil { return } var expected struct { MatchedCount int64 `bson:"matchedCount"` ModifiedCount int64 `bson:"modifiedCount"` UpsertedCount int64 `bson:"upsertedCount"` } err := bson.Unmarshal(result.(bson.Raw), &expected) assert.Nil(mt, err, "error creating UpdateResult: %v", err) assert.Equal(mt, expected.MatchedCount, res.MatchedCount, "matched count mismatch; expected %v, got %v", expected.MatchedCount, res.MatchedCount) assert.Equal(mt, expected.ModifiedCount, res.ModifiedCount, "modified count mismatch; expected %v, got %v", expected.ModifiedCount, res.ModifiedCount) actualUpsertedCount := int64(0) if res.UpsertedID != nil { actualUpsertedCount = 1 } assert.Equal(mt, expected.UpsertedCount, actualUpsertedCount, "upserted count mismatch; expected %v, got %v", expected.UpsertedCount, actualUpsertedCount) } func verifyDeleteResult(mt mtest.T, res mongo.DeleteResult, result interface{}) { mt.Helper() if result == nil { return } var expected struct { DeletedCount int64 `bson:"deletedCount"` } err := bson.Unmarshal(result.(bson.Raw), &expected) assert.Nil(mt, err, "error creating Delete result: %v", err) assert.Equal(mt, expected.DeletedCount, res.DeletedCount, "deleted count mismatch; expected %v, got %v", expected.DeletedCount, res.DeletedCount) } func verifyDistinctResult(mt mtest.T, actualResult []interface{}, expectedResult interface{}) { mt.Helper() if expectedResult == nil { return } for i, expected := range expectedResult.(bson.A) { actual := actualResult[i] iExpected := getIntFromInterface(expected) iActual := getIntFromInterface(actual) if iExpected != nil { assert.NotNil(mt, iActual, "expected nil but got %v", iActual) assert.Equal(mt, iExpected, iActual, "expected value %v but got %v", iExpected, iActual) continue } assert.Equal(mt, expected, actual, "expected value %v but got %v", expected, actual) } } func verifyInsertOneResult(mt mtest.T, actualResult mongo.InsertOneResult, expectedResult interface{}) { mt.Helper() if expectedResult == nil { return } var expected mongo.InsertOneResult err := bson.Unmarshal(expectedResult.(bson.Raw), &expected) assert.Nil(mt, err, "error creating InsertOne result: %v", err) expectedID := expected.InsertedID if f, ok := expectedID.(float64); ok && f == math.Floor(f) { expectedID = int32(f) } if expectedID != nil { assert.NotNil(mt, actualResult, "expected result but got nil") assert.Equal(mt, expectedID, actualResult.InsertedID, "inserted ID mismatch; expected %v, got %v", expectedID, actualResult.InsertedID) } } func verifyInsertManyResult(mt mtest.T, actualResult mongo.InsertManyResult, expectedResult interface{}) { mt.Helper() if expectedResult == nil { return } assert.NotNil(mt, actualResult, "expected InsertMany result %v but got nil", expectedResult) var expected struct{ InsertedIds map[string]interface{} } err := bson.Unmarshal(expectedResult.(bson.Raw), &expected) assert.Nil(mt, err, "error creating expected InsertMany result: %v", err) for _, val := range expected.InsertedIds { var found bool for _, inserted := range actualResult.InsertedIDs { if val == inserted { found = true break } } assert.True(mt, found, "expected to find ID %v in %v", val, actualResult.InsertedIDs) } } func verifyListDatabasesResult(mt mtest.T, actualResult mongo.ListDatabasesResult, expectedResult interface{}) { mt.Helper() if expectedResult == nil { return } var expected mongo.ListDatabasesResult err := bson.Unmarshal(expectedResult.(bson.Raw), &expected) assert.Nil(mt, err, "error creating ListDatabasesResult result: %v", err) assert.Equal(mt, expected, actualResult, "ListDatabasesResult mismatch; expected %v, got %v", expected, actualResult) } func verifyCursorResult(mt mtest.T, cur mongo.Cursor, result interface{}) { mt.Helper() // The Atlas Data Lake tests expect a getMore to be sent even though the operation does not have a Result field. // To account for this, we fetch all documents via cursor.All and then compare them to the result if it's non-nil. assert.NotNil(mt, cur, "expected cursor to not be nil") var actual []bson.Raw err := cur.All(context.Background(), &actual) assert.Nil(mt, err, "All error: %v", err) if result == nil { return } resultsArray := result.(bson.A) assert.Equal(mt, len(resultsArray), len(actual), "expected %d documents from cursor, got %d", len(resultsArray), len(actual)) for i, expected := range resultsArray { err := compareDocs(mt, expected.(bson.Raw), actual[i]) assert.Nil(mt, err, "cursor document mismatch at index %d: %v", i, err) } } func verifySingleResult(mt mtest.T, actualResult *mongo.SingleResult, expectedResult interface{}) { mt.Helper() if expectedResult == nil { return } expected := expectedResult.(bson.Raw) actual, _ := actualResult.Raw() if err := compareDocs(mt, expected, actual); err != nil { mt.Fatalf("SingleResult document mismatch: %s", err) } }	45.26 KB	2025-05-25 12:27
📄 crud_prose_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "bytes" "context" "errors" "testing" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) func TestWriteErrorsWithLabels(t testing.T) { clientOpts := options.Client().SetRetryWrites(false).SetWriteConcern(mtest.MajorityWc). SetReadConcern(mtest.MajorityRc) mtOpts := mtest.NewOptions().ClientOptions(clientOpts).MinServerVersion("4.0").Topologies(mtest.ReplicaSet). CreateClient(false) mt := mtest.New(t, mtOpts) label := "ExampleError" mt.Run("InsertMany errors with label", func(mt mtest.T) { mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"insert"}, WriteConcernError: &mtest.WriteConcernErrorData{ Code: 100, ErrorLabels: &[]string{label}, }, }, }) _, err := mt.Coll.InsertMany(context.Background(), []interface{}{ bson.D{ {"a", 1}, }, bson.D{ {"a", 2}, }, }) assert.NotNil(mt, err, "expected non-nil error, got nil") we, ok := err.(mongo.BulkWriteException) assert.True(mt, ok, "expected mongo.BulkWriteException, got %T", err) assert.True(mt, we.HasErrorLabel(label), "expected error to have label: %v", label) }) mt.Run("WriteException with label", func(mt mtest.T) { mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"delete"}, WriteConcernError: &mtest.WriteConcernErrorData{ Code: 100, ErrorLabels: &[]string{label}, }, }, }) _, err := mt.Coll.DeleteMany(context.Background(), bson.D{{"a", 1}}) assert.NotNil(mt, err, "expected non-nil error, got nil") we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected mongo.WriteException, got %T", err) assert.True(mt, we.HasErrorLabel(label), "expected error to have label: %v", label) }) mt.Run("BulkWriteException with label", func(mt mtest.T) { mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"delete"}, WriteConcernError: &mtest.WriteConcernErrorData{ Code: 100, ErrorLabels: &[]string{label}, }, }, }) models := []mongo.WriteModel{ &mongo.InsertOneModel{bson.D{{"a", 2}}}, &mongo.DeleteOneModel{bson.D{{"a", 2}}, nil, nil}, } _, err := mt.Coll.BulkWrite(context.Background(), models) assert.NotNil(mt, err, "expected non-nil error, got nil") we, ok := err.(mongo.BulkWriteException) assert.True(mt, ok, "expected mongo.BulkWriteException, got %T", err) assert.True(mt, we.HasErrorLabel(label), "expected error to have label: %v", label) }) } func TestWriteErrorsDetails(t testing.T) { clientOpts := options.Client(). SetRetryWrites(false). SetWriteConcern(mtest.MajorityWc). SetReadConcern(mtest.MajorityRc) mtOpts := mtest.NewOptions(). ClientOptions(clientOpts). MinServerVersion("5.0"). Topologies(mtest.ReplicaSet, mtest.Single). CreateClient(false) mt := mtest.New(t, mtOpts) mt.Run("JSON Schema validation", func(mt mtest.T) { // Create a JSON Schema validator document that requires properties "a" and "b". Use it in // the collection creation options so that collections created for subtests have the JSON // Schema validator applied. validator := bson.M{ "$jsonSchema": bson.M{ "bsonType": "object", "required": []string{"a", "b"}, "properties": bson.M{ "a": bson.M{"bsonType": "string"}, "b": bson.M{"bsonType": "int"}, }, }, } cco := options.CreateCollection().SetValidator(validator) validatorOpts := mtest.NewOptions().CollectionCreateOptions(cco) cases := []struct { desc string operation func(mongo.Collection) error expectBulkError bool expectedCommandName string }{ { desc: "InsertOne schema validation errors should include Details", operation: func(coll mongo.Collection) error { // Try to insert a document that doesn't contain the required properties. _, err := coll.InsertOne(context.Background(), bson.D{{"nope", 1}}) return err }, expectBulkError: false, expectedCommandName: "insert", }, { desc: "InsertMany schema validation errors should include Details", operation: func(coll mongo.Collection) error { // Try to insert a document that doesn't contain the required properties. _, err := coll.InsertMany(context.Background(), []interface{}{bson.D{{"nope", 1}}}) return err }, expectBulkError: true, expectedCommandName: "insert", }, { desc: "UpdateOne schema validation errors should include Details", operation: func(coll mongo.Collection) error { // Try to set "a" to be an int, which violates the string type requirement. _, err := coll.UpdateOne( context.Background(), bson.D{}, bson.D{{"$set", bson.D{{"a", 1}}}}) return err }, expectBulkError: false, expectedCommandName: "update", }, { desc: "UpdateMany schema validation errors should include Details", operation: func(coll mongo.Collection) error { // Try to set "a" to be an int in all documents in the collection, which violates // the string type requirement. _, err := coll.UpdateMany( context.Background(), bson.D{}, bson.D{{"$set", bson.D{{"a", 1}}}}) return err }, expectBulkError: false, expectedCommandName: "update", }, } for _, tc := range cases { mt.RunOpts(tc.desc, validatorOpts, func(mt mtest.T) { // Insert two valid documents so that the Update* tests can try to update them. { _, err := mt.Coll.InsertMany( context.Background(), []interface{}{ bson.D{{"a", "str1"}, {"b", 1}}, bson.D{{"a", "str2"}, {"b", 2}}, }) assert.Nil(mt, err, "unexpected error inserting valid documents: %s", err) } err := tc.operation(mt.Coll) assert.NotNil(mt, err, "expected an error from calling the operation") sErr := err.(mongo.ServerError) assert.True( mt, sErr.HasErrorCode(121), "expected mongo.ServerError to have error code 121 (DocumentValidationFailure)") var details bson.Raw if tc.expectBulkError { bwe, ok := err.(mongo.BulkWriteException) assert.True( mt, ok, "expected error to be type mongo.BulkWriteException, got type %T (error %q)", err, err) // Assert that there is one WriteError and that the Details field is populated. assert.Equal( mt, 1, len(bwe.WriteErrors), "expected exactly 1 write error, but got %d write errors (error %q)", len(bwe.WriteErrors), err) details = bwe.WriteErrors[0].Details } else { we, ok := err.(mongo.WriteException) assert.True( mt, ok, "expected error to be type mongo.WriteException, got type %T (error %q)", err, err) // Assert that there is one WriteError and that the Details field is populated. assert.Equal( mt, 1, len(we.WriteErrors), "expected exactly 1 write error, but got %d write errors (error %q)", len(we.WriteErrors), err) details = we.WriteErrors[0].Details } assert.True( mt, len(details) > 0, "expected WriteError.Details to be populated, but is empty") // Assert that the most recent CommandSucceededEvent was triggered by the expected // operation and contains the resulting write errors and that // "writeErrors[0].errInfo" is the same as "WriteException.WriteErrors[0].Details". evts := mt.GetAllSucceededEvents() assert.True( mt, len(evts) >= 2, "expected there to be at least 2 CommandSucceededEvent recorded") evt := evts[len(evts)-1] assert.Equal( mt, tc.expectedCommandName, evt.CommandName, "expected the last CommandSucceededEvent to be for %q, was %q", tc.expectedCommandName, evt.CommandName) errInfo, ok := evt.Reply.Lookup("writeErrors", "0", "errInfo").DocumentOK() assert.True( mt, ok, "expected evt.Reply to contain writeErrors[0].errInfo but doesn't (evt.Reply = %v)", evt.Reply) assert.Equal(mt, details, errInfo, "want %v, got %v", details, errInfo) }) } }) } func TestHintErrors(t testing.T) { mtOpts := mtest.NewOptions().MaxServerVersion("3.2").CreateClient(false) mt := mtest.New(t, mtOpts) expected := errors.New("the 'hint' command parameter requires a minimum server wire version of 5") mt.Run("UpdateMany", func(mt mtest.T) { _, got := mt.Coll.UpdateMany(context.Background(), bson.D{{"a", 1}}, bson.D{{"$inc", bson.D{{"a", 1}}}}, options.Update().SetHint("_id_")) assert.NotNil(mt, got, "expected non-nil error, got nil") assert.Equal(mt, got, expected, "expected: %v got: %v", expected, got) }) mt.Run("ReplaceOne", func(mt mtest.T) { _, got := mt.Coll.ReplaceOne(context.Background(), bson.D{{"a", 1}}, bson.D{{"a", 2}}, options.Replace().SetHint("_id_")) assert.NotNil(mt, got, "expected non-nil error, got nil") assert.Equal(mt, got, expected, "expected: %v got: %v", expected, got) }) mt.Run("BulkWrite", func(mt mtest.T) { models := []mongo.WriteModel{ &mongo.InsertOneModel{bson.D{{"_id", 2}}}, &mongo.ReplaceOneModel{Filter: bson.D{{"_id", 2}}, Replacement: bson.D{{"a", 2}}, Hint: "_id_"}, } _, got := mt.Coll.BulkWrite(context.Background(), models) assert.NotNil(mt, got, "expected non-nil error, got nil") assert.Equal(mt, got, expected, "expected: %v got: %v", expected, got) }) } func TestWriteConcernError(t testing.T) { mt := mtest.New(t, noClientOpts) errInfoOpts := mtest.NewOptions().MinServerVersion("4.0").Topologies(mtest.ReplicaSet) mt.RunOpts("errInfo is propagated", errInfoOpts, func(mt mtest.T) { wcDoc := bsoncore.BuildDocumentFromElements(nil, bsoncore.AppendInt32Element(nil, "w", 2), bsoncore.AppendInt32Element(nil, "wtimeout", 0), bsoncore.AppendStringElement(nil, "provenance", "clientSupplied"), ) errInfoDoc := bsoncore.BuildDocumentFromElements(nil, bsoncore.AppendDocumentElement(nil, "writeConcern", wcDoc), ) fp := mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"insert"}, WriteConcernError: &mtest.WriteConcernErrorData{ Code: 100, Name: "UnsatisfiableWriteConcern", Errmsg: "Not enough data-bearing nodes", ErrInfo: errInfoDoc, }, }, } mt.SetFailPoint(fp) _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"x", 1}}) assert.NotNil(mt, err, "expected InsertOne error, got nil") writeException, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected WriteException, got error %v of type %T", err, err) wcError := writeException.WriteConcernError assert.NotNil(mt, wcError, "expected write-concern error, got %v", err) assert.True(mt, bytes.Equal(wcError.Details, errInfoDoc), "expected errInfo document %v, got %v", bson.Raw(errInfoDoc), wcError.Details) }) } func TestErrorsCodeNamePropagated(t testing.T) { // Ensure the codeName field is propagated for both command and write concern errors. mtOpts := mtest.NewOptions(). Topologies(mtest.ReplicaSet). CreateClient(false) mt := mtest.New(t, mtOpts) mt.RunOpts("command error", mtest.NewOptions().MinServerVersion("3.4"), func(mt mtest.T) { // codeName is propagated in an ok:0 error. cmd := bson.D{ {"insert", mt.Coll.Name()}, {"documents", []bson.D{}}, } err := mt.DB.RunCommand(context.Background(), cmd).Err() assert.NotNil(mt, err, "expected RunCommand error, got nil") ce, ok := err.(mongo.CommandError) assert.True(mt, ok, "expected error of type %T, got %v of type %T", mongo.CommandError{}, err, err) expectedCodeName := "InvalidLength" assert.Equal(mt, expectedCodeName, ce.Name, "expected error code name %q, got %q", expectedCodeName, ce.Name) }) wcCollOpts := options.Collection(). SetWriteConcern(impossibleWc) wcMtOpts := mtest.NewOptions(). CollectionOptions(wcCollOpts) mt.RunOpts("write concern error", wcMtOpts, func(mt *mtest.T) { // codeName is propagated for write concern errors. _, err := mt.Coll.InsertOne(context.Background(), bson.D{}) assert.NotNil(mt, err, "expected InsertOne error, got nil") we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected error of type %T, got %v of type %T", mongo.WriteException{}, err, err) wce := we.WriteConcernError assert.NotNil(mt, wce, "expected write concern error, got %v", we) var expectedCodeName string if codeNameVal, err := mt.GetSucceededEvent().Reply.LookupErr("writeConcernError", "codeName"); err == nil { expectedCodeName = codeNameVal.StringValue() } assert.Equal(mt, expectedCodeName, wce.Name, "expected code name %q, got %q", expectedCodeName, wce.Name) }) }	13.3 KB	2025-05-25 12:27
📄 crud_spec_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "fmt" "io/ioutil" "os" "path" "reflect" "strings" "testing" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/bsonutil" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" ) const ( crudTestsDir = "../../testdata/crud" crudReadDir = "v1/read" crudWriteDir = "v1/write" ) type crudTestFile struct { Data []bson.Raw `bson:"data"` MinServerVersion string `bson:"minServerVersion"` MaxServerVersion string `bson:"maxServerVersion"` Serverless string `bson:"serverless"` Tests []crudTest `bson:"tests"` } type crudTest struct { Description string `bson:"description"` SkipReason string `bson:"skipReason"` Operation crudOperation `bson:"operation"` Outcome crudOutcome `bson:"outcome"` } type crudOperation struct { Name string `bson:"name"` Arguments bson.Raw `bson:"arguments"` } type crudOutcome struct { Error bool `bson:"error"` // only used by retryable writes tests Result interface{} `bson:"result"` Collection outcomeCollection `bson:"collection"` } var crudRegistry = bson.NewRegistryBuilder(). RegisterTypeMapEntry(bson.TypeEmbeddedDocument, reflect.TypeOf(bson.Raw{})).Build() func TestCrudSpec(t testing.T) { for _, dir := range []string{crudReadDir, crudWriteDir} { for _, file := range jsonFilesInDir(t, path.Join(crudTestsDir, dir)) { t.Run(file, func(t testing.T) { runCrudFile(t, path.Join(crudTestsDir, dir, file)) }) } } } func verifyServerlessConstraint(mt mtest.T, expected string) error { serverless := os.Getenv("SERVERLESS") == "serverless" switch expected { case "require": if !serverless { return fmt.Errorf("test requires serverless") } case "forbid": if serverless { return fmt.Errorf("test forbids serverless") } case "allow", "": default: mt.Fatalf("invalid value for serverless: %s", expected) } return nil } func runCrudFile(t testing.T, file string) { content, err := ioutil.ReadFile(file) assert.Nil(t, err, "ReadFile error for %v: %v", file, err) var testFile crudTestFile err = bson.UnmarshalExtJSONWithRegistry(crudRegistry, content, false, &testFile) assert.Nil(t, err, "UnmarshalExtJSONWithRegistry error: %v", err) mt := mtest.New(t, mtest.NewOptions().MinServerVersion(testFile.MinServerVersion).MaxServerVersion(testFile.MaxServerVersion)) // Skip test if serverless requirements are not met. if err = verifyServerlessConstraint(mt, testFile.Serverless); err != nil { mt.Skipf("%v", err) } for _, test := range testFile.Tests { mt.Run(test.Description, func(mt mtest.T) { runCrudTest(mt, test, testFile) }) } } func runCrudTest(mt mtest.T, test crudTest, testFile crudTestFile) { if len(testFile.Data) > 0 { docs := bsonutil.RawToInterfaces(testFile.Data...) _, err := mt.Coll.InsertMany(context.Background(), docs) assert.Nil(mt, err, "InsertMany error: %v", err) } runCrudOperation(mt, test.Description, test.Operation, test.Outcome) } func verifyCrudError(mt mtest.T, outcome crudOutcome, err error) { opError := errorFromResult(mt, outcome.Result) if opError == nil { return } verificationErr := verifyError(opError, err) assert.Nil(mt, verificationErr, "error mismatch: %v", verificationErr) } // run a CRUD operation and verify errors and outcomes. // the test description is needed to see determine if the test is an aggregate with $out func runCrudOperation(mt *mtest.T, testDescription string, operation crudOperation, outcome crudOutcome) { switch operation.Name { case "aggregate": cursor, err := executeAggregate(mt, mt.Coll, nil, operation.Arguments) if outcome.Error { assert.NotNil(mt, err, "expected Aggregate error, got nil") verifyCrudError(mt, outcome, err) break } assert.Nil(mt, err, "Aggregate error: %v", err) // only verify cursor contents for pipelines without $out if !strings.Contains(testDescription, "$out") { verifyCursorResult(mt, cursor, outcome.Result) } case "bulkWrite": res, err := executeBulkWrite(mt, nil, operation.Arguments) if outcome.Error { assert.NotNil(mt, err, "expected BulkWrite error, got nil") verifyCrudError(mt, outcome, err) break } assert.Nil(mt, err, "BulkWrite error: %v", err) verifyBulkWriteResult(mt, res, outcome.Result) case "count": res, err := executeCountDocuments(mt, nil, operation.Arguments) if outcome.Error { assert.NotNil(mt, err, "expected CountDocuments error, got nil") verifyCrudError(mt, outcome, err) break } assert.Nil(mt, err, "CountDocuments error: %v", err) verifyCountResult(mt, res, outcome.Result) case "distinct": res, err := executeDistinct(mt, nil, operation.Arguments) if outcome.Error { assert.NotNil(mt, err, "expected Distinct error, got nil") verifyCrudError(mt, outcome, err) break } assert.Nil(mt, err, "Distinct error: %v", err) verifyDistinctResult(mt, res, outcome.Result) case "find": cursor, err := executeFind(mt, nil, operation.Arguments) if outcome.Error { assert.NotNil(mt, err, "expected Find error, got nil") verifyCrudError(mt, outcome, err) break } assert.Nil(mt, err, "Find error: %v", err) verifyCursorResult(mt, cursor, outcome.Result) case "deleteOne": res, err := executeDeleteOne(mt, nil, operation.Arguments) if outcome.Error { assert.NotNil(mt, err, "expected DeleteOne error, got nil") verifyCrudError(mt, outcome, err) break } assert.Nil(mt, err, "DeleteOne error: %v", err) verifyDeleteResult(mt, res, outcome.Result) case "deleteMany": res, err := executeDeleteMany(mt, nil, operation.Arguments) if outcome.Error { assert.NotNil(mt, err, "expected DeleteMany error, got nil") verifyCrudError(mt, outcome, err) break } assert.Nil(mt, err, "DeleteMany error: %v", err) verifyDeleteResult(mt, res, outcome.Result) case "findOneAndDelete": res := executeFindOneAndDelete(mt, nil, operation.Arguments) err := res.Err() if outcome.Error { assert.NotNil(mt, err, "expected FindOneAndDelete error, got nil") verifyCrudError(mt, outcome, err) break } if outcome.Result == nil { assert.Equal(mt, mongo.ErrNoDocuments, err, "expected error %v, got %v", mongo.ErrNoDocuments, err) break } assert.Nil(mt, err, "FindOneAndDelete error: %v", err) verifySingleResult(mt, res, outcome.Result) case "findOneAndReplace": res := executeFindOneAndReplace(mt, nil, operation.Arguments) err := res.Err() if outcome.Error { assert.NotNil(mt, err, "expected FindOneAndReplace error, got nil") verifyCrudError(mt, outcome, err) break } if outcome.Result == nil { assert.Equal(mt, mongo.ErrNoDocuments, err, "expected error %v, got %v", mongo.ErrNoDocuments, err) break } assert.Nil(mt, err, "FindOneAndReplace error: %v", err) verifySingleResult(mt, res, outcome.Result) case "findOneAndUpdate": res := executeFindOneAndUpdate(mt, nil, operation.Arguments) err := res.Err() if outcome.Error { assert.NotNil(mt, err, "expected FindOneAndUpdate error, got nil") verifyCrudError(mt, outcome, err) break } if outcome.Result == nil { assert.Equal(mt, mongo.ErrNoDocuments, err, "expected error %v, got %v", mongo.ErrNoDocuments, err) break } assert.Nil(mt, err, "FindOneAndUpdate error: %v", err) verifySingleResult(mt, res, outcome.Result) case "insertOne": res, err := executeInsertOne(mt, nil, operation.Arguments) if outcome.Error { assert.NotNil(mt, err, "expected InsertOne error, got nil") verifyCrudError(mt, outcome, err) break } assert.Nil(mt, err, "InsertOne error: %v", err) verifyInsertOneResult(mt, res, outcome.Result) case "insertMany": res, err := executeInsertMany(mt, nil, operation.Arguments) if outcome.Error { assert.NotNil(mt, err, "expected InsertMany error, got nil") verifyCrudError(mt, outcome, err) break } assert.Nil(mt, err, "InsertMany error: %v", err) verifyInsertManyResult(mt, res, outcome.Result) case "replaceOne": res, err := executeReplaceOne(mt, nil, operation.Arguments) if outcome.Error { assert.NotNil(mt, err, "expected ReplaceOne error, got nil") verifyCrudError(mt, outcome, err) break } assert.Nil(mt, err, "ReplaceOne error: %v", err) verifyUpdateResult(mt, res, outcome.Result) case "updateOne": res, err := executeUpdateOne(mt, nil, operation.Arguments) if outcome.Error { assert.NotNil(mt, err, "expected UpdateOne error, got nil") verifyCrudError(mt, outcome, err) break } assert.Nil(mt, err, "UpdateOne error: %v", err) verifyUpdateResult(mt, res, outcome.Result) case "updateMany": res, err := executeUpdateMany(mt, nil, operation.Arguments) if outcome.Error { assert.NotNil(mt, err, "expected UpdateMany error, got nil") verifyCrudError(mt, outcome, err) break } assert.Nil(mt, err, "UpdateMany error: %v", err) verifyUpdateResult(mt, res, outcome.Result) case "estimatedDocumentCount": res, err := executeEstimatedDocumentCount(mt, nil, operation.Arguments) if outcome.Error { assert.NotNil(mt, err, "expected EstimatedDocumentCount error, got nil") verifyCrudError(mt, outcome, err) break } assert.Nil(mt, err, "EstimatedDocumentCount error: %v", err) verifyCountResult(mt, res, outcome.Result) case "countDocuments": res, err := executeCountDocuments(mt, nil, operation.Arguments) if outcome.Error { assert.NotNil(mt, err, "expected CountDocuments error, got nil") verifyCrudError(mt, outcome, err) break } assert.Nil(mt, err, "CountDocuments error: %v", err) verifyCountResult(mt, res, outcome.Result) default: mt.Fatalf("unrecognized operation: %v", operation.Name) } if outcome.Collection != nil { verifyTestOutcome(mt, outcome.Collection) } }	9.94 KB	2025-05-25 12:27
📄 csot_cse_prose_test.go // Copyright (C) MongoDB, Inc. 2022-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 //go:build cse // +build cse package integration import ( "context" "testing" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/integtest" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" ) // CSOT prose tests that require the 'cse' Go build tag. func TestCSOTClientSideEncryptionProse(t testing.T) { verifyClientSideEncryptionVarsSet(t) mt := mtest.New(t, mtest.NewOptions().MinServerVersion("4.2").CreateClient(false)) mt.RunOpts("2. maxTimeMS is not set for commands sent to mongocryptd", noClientOpts, func(mt mtest.T) { kmsProviders := map[string]map[string]interface{}{ "local": { "key": localMasterKey, }, } mongocryptdSpawnArgs := map[string]interface{}{ // Pass a custom pidfilepath to ensure a new mongocryptd process is spawned. "mongocryptdSpawnArgs": []string{"--port=23000", "--pidfilepath=TestCSOTClientSideEncryptionProse_1.pid"}, "mongocryptdURI": "mongodb://localhost:23000", // Do not use the shared library to ensure mongocryptd is spawned. "__cryptSharedLibDisabledForTestOnly": true, } // Setup encrypted client to cause spawning of mongocryptd on port 23000. aeo := options.AutoEncryption().SetKmsProviders(kmsProviders). SetExtraOptions(mongocryptdSpawnArgs) cliOpts := options.Client().ApplyURI(mtest.ClusterURI()).SetAutoEncryptionOptions(aeo) integtest.AddTestServerAPIVersion(cliOpts) encClient, err := mongo.Connect(context.Background(), cliOpts) assert.Nil(mt, err, "Connect error: %v", err) defer func() { err = encClient.Disconnect(context.Background()) assert.Nil(mt, err, "encrypted client Disconnect error: %v", err) }() // Run a Find through the encrypted client to make sure mongocryptd is started ('find' uses the // mongocryptd and will wait for it to be active). _, err = encClient.Database("test").Collection("test").Find(context.Background(), bson.D{}) assert.Nil(mt, err, "Find error: %v", err) // Use a new Client to connect to 23000 where mongocryptd should be running. Use a custom // command monitor to examine the eventual 'ping'. var started event.CommandStartedEvent mcryptMonitor := &event.CommandMonitor{ Started: func(_ context.Context, evt event.CommandStartedEvent) { started = evt }, } mcryptOpts := options.Client().SetMonitor(mcryptMonitor). ApplyURI("mongodb://localhost:23000/?timeoutMS=1000") integtest.AddTestServerAPIVersion(mcryptOpts) mcryptClient, err := mongo.Connect(context.Background(), mcryptOpts) assert.Nil(mt, err, "mongocryptd Connect error: %v", err) defer func() { err = mcryptClient.Disconnect(context.Background()) assert.Nil(mt, err, "mongocryptd Disconnect error: %v", err) }() // Run Ping and assert that sent command does not contain 'maxTimeMS'. The 'ping' command // does not exist on mongocryptd, so ignore the CommandNotFound error. _ = mcryptClient.Ping(context.Background(), nil) assert.NotNil(mt, started, "expected a CommandStartedEvent, got nil") assert.Equal(mt, started.CommandName, "ping", "expected 'ping', got %q", started.CommandName) commandElems, err := started.Command.Elements() assert.Nil(mt, err, "Elements error: %v", err) for _, elem := range commandElems { assert.NotEqual(mt, elem.Key(), "maxTimeMS", "expected no 'maxTimeMS' field in ping to mongocryptd") } }) }	3.76 KB	2025-05-25 12:27
📄 csot_prose_test.go // Copyright (C) MongoDB, Inc. 2022-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "strings" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/integtest" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" ) func TestCSOTProse(t testing.T) { mt := mtest.New(t, mtest.NewOptions().CreateClient(false)) mt.RunOpts("1. multi-batch writes", mtest.NewOptions().MinServerVersion("4.4"). Topologies(mtest.Single), func(mt mtest.T) { // Test that multi-batch writes do not refresh the Timeout between batches. err := mt.Client.Database("db").Collection("coll").Drop(context.Background()) assert.Nil(mt, err, "Drop error: %v", err) // Configure a fail point to block both inserts of the multi-write for 1010ms (2020ms total). mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 2, }, Data: mtest.FailPointData{ FailCommands: []string{"insert"}, BlockConnection: true, BlockTimeMS: 1010, }, }) // Use a separate client with 2s Timeout and a separate command monitor to run a multi-batch // insert against db.coll. var started []event.CommandStartedEvent cm := &event.CommandMonitor{ Started: func(_ context.Context, evt event.CommandStartedEvent) { started = append(started, evt) }, } cliOptions := options.Client(). SetTimeout(2 * time.Second). SetMonitor(cm). ApplyURI(mtest.ClusterURI()) integtest.AddTestServerAPIVersion(cliOptions) cli, err := mongo.Connect(context.Background(), cliOptions) assert.Nil(mt, err, "Connect error: %v", err) // Insert 50 1MB documents (OP_MSG payloads can only fit 48MB in one batch). var bigStringBuilder strings.Builder for i := 0; i < 10241024; i++ { bigStringBuilder.WriteByte('a') } bigString := bigStringBuilder.String() var docs []interface{} for i := 0; i < 50; i++ { docs = append(docs, bson.D{{"1mb", bigString}}) } // Expect a timeout error from InsertMany (from the second batch). _, err = cli.Database("db").Collection("coll").InsertMany(context.Background(), docs) assert.NotNil(mt, err, "expected error from InsertMany, got nil") assert.True(mt, mongo.IsTimeout(err), "expected error to be a timeout, got %v", err) // Expect that two 'insert's were sent. assert.True(mt, len(started) == 2, "expected two started events, got %d", len(started)) assert.Equal(mt, started[0].CommandName, "insert", "expected an insert event, got %v", started[0].CommandName) assert.Equal(mt, started[1].CommandName, "insert", "expected a second insert event, got %v", started[1].CommandName) }) mt.Run("8. server selection", func(mt mtest.T) { cliOpts := options.Client().ApplyURI("mongodb://invalid/?serverSelectionTimeoutMS=100") mtOpts := mtest.NewOptions().ClientOptions(cliOpts).CreateCollection(false) mt.RunOpts("serverSelectionTimeoutMS honored if timeoutMS is not set", mtOpts, func(mt mtest.T) { mt.Parallel() callback := func(ctx context.Context) { err := mt.Client.Ping(ctx, nil) assert.NotNil(mt, err, "expected Ping error, got nil") } // Assert that Ping fails within 150ms due to server selection timeout. assert.Soon(mt, callback, 150time.Millisecond) }) cliOpts = options.Client().ApplyURI("mongodb://invalid/?timeoutMS=100&serverSelectionTimeoutMS=200") mtOpts = mtest.NewOptions().ClientOptions(cliOpts).CreateCollection(false) mt.RunOpts("timeoutMS honored for server selection if it's lower than serverSelectionTimeoutMS", mtOpts, func(mt mtest.T) { mt.Parallel() callback := func(ctx context.Context) { err := mt.Client.Ping(ctx, nil) assert.NotNil(mt, err, "expected Ping error, got nil") } // Assert that Ping fails within 150ms due to timeout. assert.Soon(mt, callback, 150time.Millisecond) }) cliOpts = options.Client().ApplyURI("mongodb://invalid/?timeoutMS=200&serverSelectionTimeoutMS=100") mtOpts = mtest.NewOptions().ClientOptions(cliOpts).CreateCollection(false) mt.RunOpts("serverSelectionTimeoutMS honored for server selection if it's lower than timeoutMS", mtOpts, func(mt mtest.T) { mt.Parallel() callback := func(ctx context.Context) { err := mt.Client.Ping(ctx, nil) assert.NotNil(mt, err, "expected Ping error, got nil") } // Assert that Ping fails within 150ms due to server selection timeout. assert.Soon(mt, callback, 150time.Millisecond) }) cliOpts = options.Client().ApplyURI("mongodb://invalid/?timeoutMS=0&serverSelectionTimeoutMS=100") mtOpts = mtest.NewOptions().ClientOptions(cliOpts).CreateCollection(false) mt.RunOpts("serverSelectionTimeoutMS honored for server selection if timeoutMS=0", mtOpts, func(mt mtest.T) { mt.Parallel() callback := func(ctx context.Context) { err := mt.Client.Ping(ctx, nil) assert.NotNil(mt, err, "expected Ping error, got nil") } // Assert that Ping fails within 150ms due to server selection timeout. assert.Soon(mt, callback, 150time.Millisecond) }) }) }	5.32 KB	2025-05-25 12:27
📄 cursor_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "errors" "os" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" ) const ( errorCursorNotFound = 43 ) func TestCursor(t testing.T) { mt := mtest.New(t, mtest.NewOptions().CreateClient(false)) cappedCollectionOpts := options.CreateCollection().SetCapped(true).SetSizeInBytes(64 1024) // Server versions 2.6 and 3.0 use OP_GET_MORE so this works on >= 3.2 and when RequireAPIVersion is false; // getMore cannot be sent with RunCommand as server API options will be attached when they should not be. mt.RunOpts("cursor is killed on server", mtest.NewOptions().MinServerVersion("3.2").RequireAPIVersion(false), func(mt mtest.T) { initCollection(mt, mt.Coll) c, err := mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetBatchSize(2)) assert.Nil(mt, err, "Find error: %v", err) id := c.ID() assert.True(mt, c.Next(context.Background()), "expected Next true, got false") err = c.Close(context.Background()) assert.Nil(mt, err, "Close error: %v", err) err = mt.DB.RunCommand(context.Background(), bson.D{ {"getMore", id}, {"collection", mt.Coll.Name()}, }).Err() ce := err.(mongo.CommandError) assert.Equal(mt, int32(errorCursorNotFound), ce.Code, "expected error code %v, got %v", errorCursorNotFound, ce.Code) }) mt.RunOpts("try next", noClientOpts, func(mt mtest.T) { // Skip tests if running against serverless, as capped collections are banned. if os.Getenv("SERVERLESS") == "serverless" { mt.Skip("skipping as serverless forbids capped collections") } mt.Run("existing non-empty batch", func(mt mtest.T) { // If there's already documents in the current batch, TryNext should return true without doing a getMore initCollection(mt, mt.Coll) cursor, err := mt.Coll.Find(context.Background(), bson.D{}) assert.Nil(mt, err, "Find error: %v", err) defer cursor.Close(context.Background()) tryNextExistingBatchTest(mt, cursor) }) mt.RunOpts("one getMore sent", mtest.NewOptions().CollectionCreateOptions(cappedCollectionOpts), func(mt mtest.T) { // If the current batch is empty, TryNext should send one getMore and return. // insert a document because a tailable cursor will only have a non-zero ID if the initial Find matches // at least one document _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"x", 1}}) assert.Nil(mt, err, "InsertOne error: %v", err) cursor, err := mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetCursorType(options.Tailable)) assert.Nil(mt, err, "Find error: %v", err) defer cursor.Close(context.Background()) // first call to TryNext should return 1 document assert.True(mt, cursor.TryNext(context.Background()), "expected Next to return true, got false") // TryNext should attempt one getMore mt.ClearEvents() assert.False(mt, cursor.TryNext(context.Background()), "unexpected document %v", cursor.Current) verifyOneGetmoreSent(mt) }) mt.RunOpts("getMore error", mtest.NewOptions().ClientType(mtest.Mock), func(mt mtest.T) { findRes := mtest.CreateCursorResponse(50, "foo.bar", mtest.FirstBatch) mt.AddMockResponses(findRes) cursor, err := mt.Coll.Find(context.Background(), bson.D{}) assert.Nil(mt, err, "Find error: %v", err) defer cursor.Close(context.Background()) tryNextGetmoreError(mt, cursor) }) }) mt.RunOpts("RemainingBatchLength", noClientOpts, func(mt mtest.T) { cappedMtOpts := mtest.NewOptions().CollectionCreateOptions(cappedCollectionOpts) // Skip tests if running against serverless, as capped collections are banned. if os.Getenv("SERVERLESS") == "serverless" { mt.Skip("skipping as serverless forbids capped collections") } mt.RunOpts("first batch is non empty", cappedMtOpts, func(mt mtest.T) { // Test that the cursor reports the correct value for RemainingBatchLength at various execution points if // the first batch from the server is non-empty. initCollection(mt, mt.Coll) // Create a tailable await cursor with a low cursor timeout. batchSize := 2 findOpts := options.Find(). SetBatchSize(int32(batchSize)). SetCursorType(options.TailableAwait). SetMaxAwaitTime(100 time.Millisecond) cursor, err := mt.Coll.Find(context.Background(), bson.D{}, findOpts) assert.Nil(mt, err, "Find error: %v", err) defer cursor.Close(context.Background()) mt.ClearEvents() // The initial batch length should be equal to the batchSize. Do batchSize Next calls to exhaust the current // batch and assert that no getMore was done. assertCursorBatchLength(mt, cursor, batchSize) for i := 0; i < batchSize; i++ { prevLength := cursor.RemainingBatchLength() if !cursor.Next(context.Background()) { mt.Fatalf("expected Next to return true on index %d; cursor err: %v", i, cursor.Err()) } // Each successful Next call should decrement batch length by 1. assertCursorBatchLength(mt, cursor, prevLength-1) } evt := mt.GetStartedEvent() assert.Nil(mt, evt, "expected no events, got %v", evt) // The batch is exhausted, so the batch length should be 0. Do one Next call, which should do a getMore and // fetch batchSize more documents. The batch length after the call should be (batchSize-1) because Next consumes // one document. assertCursorBatchLength(mt, cursor, 0) assert.True(mt, cursor.Next(context.Background()), "expected Next to return true; cursor err: %v", cursor.Err()) evt = mt.GetStartedEvent() assert.NotNil(mt, evt, "expected CommandStartedEvent, got nil") assert.Equal(mt, "getMore", evt.CommandName, "expected command %q, got %q", "getMore", evt.CommandName) assertCursorBatchLength(mt, cursor, batchSize-1) }) mt.RunOpts("first batch is empty", mtest.NewOptions().ClientType(mtest.Mock), func(mt mtest.T) { // Test that the cursor reports the correct value for RemainingBatchLength if the first batch is empty. // Using a mock deployment simplifies this test because the server won't create a valid cursor if the // collection is empty when the find is run. cursorID := int64(50) ns := mt.DB.Name() + "." + mt.Coll.Name() getMoreBatch := []bson.D{ {{"x", 1}}, {{"x", 2}}, } // Create mock responses. find := mtest.CreateCursorResponse(cursorID, ns, mtest.FirstBatch) getMore := mtest.CreateCursorResponse(cursorID, ns, mtest.NextBatch, getMoreBatch...) killCursors := mtest.CreateSuccessResponse() mt.AddMockResponses(find, getMore, killCursors) cursor, err := mt.Coll.Find(context.Background(), bson.D{}) assert.Nil(mt, err, "Find error: %v", err) defer cursor.Close(context.Background()) mt.ClearEvents() for { if cursor.TryNext(context.Background()) { break } assert.Nil(mt, cursor.Err(), "cursor error: %v", err) assertCursorBatchLength(mt, cursor, 0) } // TryNext consumes one document so the remaining batch size should be len(getMoreBatch)-1. assertCursorBatchLength(mt, cursor, len(getMoreBatch)-1) }) }) mt.RunOpts("all", noClientOpts, func(mt mtest.T) { failpointOpts := mtest.NewOptions().Topologies(mtest.ReplicaSet).MinServerVersion("4.0") mt.RunOpts("getMore error", failpointOpts, func(mt mtest.T) { failpointData := mtest.FailPointData{ FailCommands: []string{"getMore"}, ErrorCode: 100, } mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: "alwaysOn", Data: failpointData, }) initCollection(mt, mt.Coll) cursor, err := mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetBatchSize(2)) assert.Nil(mt, err, "Find error: %v", err) defer cursor.Close(context.Background()) var docs []bson.D err = cursor.All(context.Background(), &docs) assert.NotNil(mt, err, "expected change stream error, got nil") // make sure that a mongo.CommandError is returned instead of a driver.Error mongoErr, ok := err.(mongo.CommandError) assert.True(mt, ok, "expected mongo.CommandError, got: %T", err) assert.Equal(mt, failpointData.ErrorCode, mongoErr.Code, "expected code %v, got: %v", failpointData.ErrorCode, mongoErr.Code) }) mt.Run("deferred Close uses context.Background", func(mt mtest.T) { initCollection(mt, mt.Coll) // Find with batchSize 2 so All will run getMore for next 3 docs and error. cur, err := mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetBatchSize(2)) assert.Nil(mt, err, "Find error: %v", err) // Create a context and immediately cancel it. canceledCtx, cancel := context.WithCancel(context.Background()) cancel() // Clear "insert" and "find" events. mt.ClearEvents() // Call All with the canceled context and expect context.Canceled. var docs []bson.D err = cur.All(canceledCtx, &docs) assert.NotNil(mt, err, "expected error for All, got nil") assert.True(mt, errors.Is(err, context.Canceled), "expected context.Canceled error, got %v", err) // Assert that a "getMore" command was sent and failed (Next used the // canceled context). stEvt := mt.GetStartedEvent() assert.NotNil(mt, stEvt, `expected a "getMore" started event, got no event`) assert.Equal(mt, stEvt.CommandName, "getMore", `expected a "getMore" started event, got %q`, stEvt.CommandName) fEvt := mt.GetFailedEvent() assert.NotNil(mt, fEvt, `expected a failed "getMore" event, got no event`) assert.Equal(mt, fEvt.CommandName, "getMore", `expected a failed "getMore" event, got %q`, fEvt.CommandName) // Assert that a "killCursors" command was sent and was successful (Close // used the 2 second Client Timeout). stEvt = mt.GetStartedEvent() assert.NotNil(mt, stEvt, `expected a "killCursors" started event, got no event`) assert.Equal(mt, stEvt.CommandName, "killCursors", `expected a "killCursors" started event, got %q`, stEvt.CommandName) suEvt := mt.GetSucceededEvent() assert.NotNil(mt, suEvt, `expected a successful "killCursors" event, got no event`) assert.Equal(mt, suEvt.CommandName, "killCursors", `expected a successful "killCursors" event, got %q`, suEvt.CommandName) }) }) mt.RunOpts("close", noClientOpts, func(mt mtest.T) { failpointOpts := mtest.NewOptions().Topologies(mtest.ReplicaSet).MinServerVersion("4.0") mt.RunOpts("killCursors error", failpointOpts, func(mt mtest.T) { failpointData := mtest.FailPointData{ FailCommands: []string{"killCursors"}, ErrorCode: 100, } mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: "alwaysOn", Data: failpointData, }) initCollection(mt, mt.Coll) cursor, err := mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetBatchSize(2)) assert.Nil(mt, err, "Find error: %v", err) err = cursor.Close(context.Background()) assert.NotNil(mt, err, "expected change stream error, got nil") // make sure that a mongo.CommandError is returned instead of a driver.Error mongoErr, ok := err.(mongo.CommandError) assert.True(mt, ok, "expected mongo.CommandError, got: %T", err) assert.Equal(mt, failpointData.ErrorCode, mongoErr.Code, "expected code %v, got: %v", failpointData.ErrorCode, mongoErr.Code) }) }) // For versions < 3.2, the first find will get all the documents mt.RunOpts("set batchSize", mtest.NewOptions().MinServerVersion("3.2"), func(mt mtest.T) { initCollection(mt, mt.Coll) mt.ClearEvents() // create cursor with batchSize 0 cursor, err := mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetBatchSize(0)) assert.Nil(mt, err, "Find error: %v", err) defer cursor.Close(context.Background()) evt := mt.GetStartedEvent() assert.Equal(mt, "find", evt.CommandName, "expected 'find' event, got '%v'", evt.CommandName) sizeVal, err := evt.Command.LookupErr("batchSize") assert.Nil(mt, err, "expected find command to have batchSize") batchSize := sizeVal.Int32() assert.Equal(mt, int32(0), batchSize, "expected batchSize 0, got %v", batchSize) // make sure that the getMore sends the new batchSize batchCursor := mongo.BatchCursorFromCursor(cursor) batchCursor.SetBatchSize(4) assert.True(mt, cursor.Next(context.Background()), "expected Next true, got false") evt = mt.GetStartedEvent() assert.NotNil(mt, evt, "expected getMore event, got nil") assert.Equal(mt, "getMore", evt.CommandName, "expected 'getMore' event, got '%v'", evt.CommandName) sizeVal, err = evt.Command.LookupErr("batchSize") assert.Nil(mt, err, "expected getMore command to have batchSize") batchSize = sizeVal.Int32() assert.Equal(mt, int32(4), batchSize, "expected batchSize 4, got %v", batchSize) }) } type tryNextCursor interface { TryNext(context.Context) bool Err() error } func tryNextExistingBatchTest(mt mtest.T, cursor tryNextCursor) { mt.Helper() mt.ClearEvents() assert.True(mt, cursor.TryNext(context.Background()), "expected TryNext to return true, got false") evt := mt.GetStartedEvent() if evt != nil { mt.Fatalf("unexpected event sent during TryNext: %v", evt.CommandName) } } // use command monitoring to verify that a single getMore was sent func verifyOneGetmoreSent(mt mtest.T) { mt.Helper() evt := mt.GetStartedEvent() assert.NotNil(mt, evt, "expected getMore event, got nil") assert.Equal(mt, "getMore", evt.CommandName, "expected 'getMore' event, got '%v'", evt.CommandName) evt = mt.GetStartedEvent() if evt != nil { mt.Fatalf("unexpected event sent during TryNext: %v", evt.CommandName) } } // should be called in a test run with a mock deployment func tryNextGetmoreError(mt mtest.T, cursor tryNextCursor) { testErr := mtest.CommandError{ Code: 100, Message: "getMore error", Name: "CursorError", Labels: []string{"NonResumableChangeStreamError"}, } getMoreRes := mtest.CreateCommandErrorResponse(testErr) mt.AddMockResponses(getMoreRes) // first call to TryNext should return false because first batch was empty so batch cursor returns false // without doing a getMore // next call to TryNext should attempt a getMore for i := 0; i < 2; i++ { assert.False(mt, cursor.TryNext(context.Background()), "TryNext returned true on iteration %v", i) } err := cursor.Err() assert.NotNil(mt, err, "expected change stream error, got nil") // make sure that a mongo.CommandError is returned instead of a driver.Error mongoErr, ok := err.(mongo.CommandError) assert.True(mt, ok, "expected mongo.CommandError, got: %T", err) assert.Equal(mt, testErr.Code, mongoErr.Code, "expected code %v, got: %v", testErr.Code, mongoErr.Code) assert.Equal(mt, testErr.Message, mongoErr.Message, "expected message %v, got: %v", testErr.Message, mongoErr.Message) assert.Equal(mt, testErr.Name, mongoErr.Name, "expected name %v, got: %v", testErr.Name, mongoErr.Name) assert.Equal(mt, testErr.Labels, mongoErr.Labels, "expected labels %v, got: %v", testErr.Labels, mongoErr.Labels) } func assertCursorBatchLength(mt mtest.T, cursor mongo.Cursor, expected int) { batchLen := cursor.RemainingBatchLength() assert.Equal(mt, expected, batchLen, "expected remaining batch length %d, got %d", expected, batchLen) }	15.27 KB	2025-05-25 12:27
📄 data_lake_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "fmt" "testing" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" ) func TestAtlasDataLake(t testing.T) { // Prose tests against Atlas Data Lake. mt := mtest.New(t, mtest.NewOptions().AtlasDataLake(true).CreateClient(false)) getMtOpts := func() mtest.Options { return mtest.NewOptions().CollectionName("driverdata") } mt.RunOpts("killCursors", getMtOpts(), func(mt mtest.T) { // Test that the killCursors sent internally when closing a cursor uses the correct namespace and cursor ID. // Run a Find and get the cursor ID and namespace returned by the server. Use a batchSize of 2 to force the // server to keep the cursor open. cursor, err := mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetBatchSize(2)) assert.Nil(mt, err, "Find error: %v", err) findEvt := mt.GetSucceededEvent() assert.Equal(mt, "find", findEvt.CommandName, "expected command name %q, got %q", "find", findEvt.CommandName) expectedID := findEvt.Reply.Lookup("cursor", "id").Int64() expectedNS := findEvt.Reply.Lookup("cursor", "ns").StringValue() // Close the cursor, forcing a killCursors command. mt.ClearEvents() err = cursor.Close(context.Background()) assert.Nil(mt, err, "Close error: %v", err) // Extract information from the killCursors started event and assert that it sent the right cursor ID and ns. killCursorsEvt := mt.GetStartedEvent() assert.Equal(mt, "killCursors", killCursorsEvt.CommandName, "expected command name %q, got %q", "killCursors", killCursorsEvt.CommandName) actualID := killCursorsEvt.Command.Lookup("cursors", "0").Int64() killCursorsDB := killCursorsEvt.Command.Lookup("$db").StringValue() killCursorsColl := killCursorsEvt.Command.Lookup("killCursors").StringValue() actualNS := fmt.Sprintf("%s.%s", killCursorsDB, killCursorsColl) assert.Equal(mt, expectedID, actualID, "expected cursor ID %v, got %v; find event %v, killCursors event %v", expectedID, actualID, findEvt, killCursorsEvt) assert.Equal(mt, expectedNS, actualNS, "expected namespace %q, got %q; find event %v, killCursors event %v", expectedNS, actualNS, findEvt, killCursorsEvt) // Extract information from the killCursors succeeded event and assert that the right cursor was killed. var killCursorsResponse struct { CursorsKilled []int64 } err = bson.Unmarshal(mt.GetSucceededEvent().Reply, &killCursorsResponse) assert.Nil(mt, err, "error unmarshalling killCursors response: %v", err) expectedCursorsKilled := []int64{expectedID} assert.Equal(mt, expectedCursorsKilled, killCursorsResponse.CursorsKilled, "expected cursorsKilled array %v, got %v", expectedCursorsKilled, killCursorsResponse.CursorsKilled) }) mt.RunOpts("auth settings", noClientOpts, func(mt mtest.T) { // Test connectivity using different auth settings. testCases := []struct { name string authMechanism string // No auth will be used if this is "". }{ {"no auth", ""}, {"scram-sha-1", "SCRAM-SHA-1"}, {"scram-sha-256", "SCRAM-SHA-256"}, } for _, tc := range testCases { clientOpts := getBaseClientOptions() if tc.authMechanism != "" { cred := getBaseCredential(mt) cred.AuthMechanism = tc.authMechanism clientOpts.SetAuth(cred) } mtOpts := getMtOpts().ClientOptions(clientOpts) mt.RunOpts(tc.name, mtOpts, func(mt mtest.T) { err := mt.Client.Ping(context.Background(), mtest.PrimaryRp) assert.Nil(mt, err, "Ping error: %v", err) }) } }) } func getBaseClientOptions() options.ClientOptions { opts := options.Client().ApplyURI(mtest.ClusterURI()) return options.Client().SetHosts(opts.Hosts) } func getBaseCredential(mt mtest.T) options.Credential { mt.Helper() cred := options.Client().ApplyURI(mtest.ClusterURI()).Auth assert.NotNil(mt, cred, "expected options for URI %q to have a non-nil Auth field", mtest.ClusterURI()) return cred }	4.22 KB	2025-05-25 12:27
📄 database_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "errors" "fmt" "reflect" "testing" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/handshake" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/mongo/readpref" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) const ( listCollCapped = "listcoll_capped" listCollUncapped = "listcoll_uncapped" ) var ( interfaceAsMapRegistry = bson.NewRegistryBuilder(). RegisterTypeMapEntry(bsontype.EmbeddedDocument, reflect.TypeOf(bson.M{})). Build() ) func TestDatabase(t testing.T) { mt := mtest.New(t, mtest.NewOptions().CreateClient(false)) mt.RunOpts("run command", noClientOpts, func(mt mtest.T) { mt.Run("decode raw", func(mt mtest.T) { res, err := mt.DB.RunCommand(context.Background(), bson.D{{handshake.LegacyHello, 1}}).Raw() assert.Nil(mt, err, "RunCommand error: %v", err) ok, err := res.LookupErr("ok") assert.Nil(mt, err, "ok field not found in result") assert.Equal(mt, bson.TypeDouble, ok.Type, "expected ok type %v, got %v", bson.TypeDouble, ok.Type) assert.Equal(mt, 1.0, ok.Double(), "expected ok value 1.0, got %v", ok.Double()) hello, err := res.LookupErr(handshake.LegacyHelloLowercase) assert.Nil(mt, err, "legacy hello response field not found in result") assert.Equal(mt, bson.TypeBoolean, hello.Type, "expected hello type %v, got %v", bson.TypeBoolean, hello.Type) assert.True(mt, hello.Boolean(), "expected hello value true, got false") }) mt.Run("decode struct", func(mt mtest.T) { result := struct { Ok float64 `bson:"ok"` }{} err := mt.DB.RunCommand(context.Background(), bson.D{{"ping", 1}}).Decode(&result) assert.Nil(mt, err, "RunCommand error: %v", err) assert.Equal(mt, 1.0, result.Ok, "expected ok value 1.0, got %v", result.Ok) }) // We set min server version 3.6 because pre-3.6 servers use OP_QUERY, so the command document will look like // {$query: {...}, $readPreference: {...}}. Per the command monitoring spec, the $query subdocument is unwrapped // and the $readPreference is dropped for monitoring purposes, so we can't examine it. readPrefOpts := mtest.NewOptions(). Topologies(mtest.Sharded). MinServerVersion("3.6") mt.RunOpts("read pref passed to mongos", readPrefOpts, func(mt mtest.T) { // When communicating with a mongos, the supplied read preference should be passed down to the operations // layer, which should add a top-level $readPreference field to the command. runCmdOpts := options.RunCmd(). SetReadPreference(readpref.SecondaryPreferred()) err := mt.DB.RunCommand(context.Background(), bson.D{{handshake.LegacyHello, 1}}, runCmdOpts).Err() assert.Nil(mt, err, "RunCommand error: %v", err) expected := bson.Raw(bsoncore.NewDocumentBuilder(). AppendString("mode", "secondaryPreferred"). Build()) evt := mt.GetStartedEvent() assert.Equal(mt, handshake.LegacyHello, evt.CommandName, "expected legacy hello command to be sent, got %q", evt.CommandName) actual, ok := evt.Command.Lookup("$readPreference").DocumentOK() assert.True(mt, ok, "expected command %v to contain a $readPreference document", evt.Command) assert.Equal(mt, expected, actual, "expected $readPreference document %v, got %v", expected, actual) }) failpointOpts := mtest.NewOptions().MinServerVersion("4.0").Topologies(mtest.ReplicaSet) mt.RunOpts("gets result and error", failpointOpts, func(mt mtest.T) { mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"insert"}, WriteConcernError: &mtest.WriteConcernErrorData{ Code: 100, }, }, }) cmd := bson.D{ {"insert", "test"}, {"documents", bson.A{bson.D{{"a", 1}}}}, } res, gotErr := mt.DB.RunCommand(context.Background(), cmd).Raw() n, ok := res.Lookup("n").Int32OK() assert.True(mt, ok, "expected n in response") assert.Equal(mt, int32(1), n, "expected n value 1, got %v", n) writeExcept, ok := gotErr.(mongo.WriteException) assert.True(mt, ok, "expected WriteCommandError, got %T", gotErr) assert.NotNil(mt, writeExcept.WriteConcernError, "expected WriteConcernError to be non-nil") assert.Equal(mt, writeExcept.WriteConcernError.Code, 100, "expected error code 100, got %v", writeExcept.WriteConcernError.Code) }) mt.Run("multi key map command", func(mt mtest.T) { err := mt.DB.RunCommand(context.Background(), bson.M{"insert": "test", "documents": bson.A{bson.D{{"a", 1}}}}).Err() assert.Equal(mt, mongo.ErrMapForOrderedArgument{"cmd"}, err, "expected error %v, got %v", mongo.ErrMapForOrderedArgument{"cmd"}, err) }) }) dropOpts := mtest.NewOptions().DatabaseName("dropDb") mt.RunOpts("drop", dropOpts, func(mt mtest.T) { err := mt.DB.Drop(context.Background()) assert.Nil(mt, err, "Drop error: %v", err) list, err := mt.Client.ListDatabaseNames(context.Background(), bson.D{}) assert.Nil(mt, err, "ListDatabaseNames error: %v", err) for _, db := range list { if db == "dropDb" { mt.Fatal("dropped database 'dropDb' found in database names") } } }) lcNamesOpts := mtest.NewOptions().MinServerVersion("4.0") mt.RunOpts("list collection names", lcNamesOpts, func(mt mtest.T) { collName := "lcNamesCollection" mt.CreateCollection(mtest.Collection{Name: collName}, true) testCases := []struct { name string filter bson.D found bool }{ {"no filter", bson.D{}, true}, {"filter", bson.D{{"name", "lcNamesCollection"}}, true}, {"filter not found", bson.D{{"name", "123"}}, false}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { colls, err := mt.DB.ListCollectionNames(context.Background(), tc.filter) assert.Nil(mt, err, "ListCollectionNames error: %v", err) var found bool for _, coll := range colls { if coll == collName { found = true break } } assert.Equal(mt, tc.found, found, "expected to find collection: %v, found collection: %v", tc.found, found) }) } }) mt.RunOpts("list collections", noClientOpts, func(mt mtest.T) { createCollections := func(mt mtest.T, numCollections int) { mt.Helper() for i := 0; i < numCollections; i++ { mt.CreateCollection(mtest.Collection{ Name: fmt.Sprintf("list-collections-test-%d", i), }, true) } } mt.RunOpts("verify results", noClientOpts, func(mt mtest.T) { testCases := []struct { name string expectedTopology mtest.TopologyKind cappedOnly bool }{ {"standalone no filter", mtest.Single, false}, {"standalone filter", mtest.Single, true}, {"replica set no filter", mtest.ReplicaSet, false}, {"replica set filter", mtest.ReplicaSet, true}, {"sharded no filter", mtest.Sharded, false}, {"sharded filter", mtest.Sharded, true}, } for _, tc := range testCases { tcOpts := mtest.NewOptions().Topologies(tc.expectedTopology) mt.RunOpts(tc.name, tcOpts, func(mt mtest.T) { mt.CreateCollection(mtest.Collection{Name: listCollUncapped}, true) mt.CreateCollection(mtest.Collection{ Name: listCollCapped, CreateOpts: options.CreateCollection().SetCapped(true).SetSizeInBytes(64 * 1024), }, true) filter := bson.D{} if tc.cappedOnly { filter = bson.D{{"options.capped", true}} } var err error for i := 0; i < 1; i++ { cursor, err := mt.DB.ListCollections(context.Background(), filter) assert.Nil(mt, err, "ListCollections error (iteration %v): %v", i, err) err = verifyListCollections(cursor, tc.cappedOnly) if err == nil { return } } mt.Fatalf("error verifying list collections result: %v", err) }) } }) // For server versions below 3.0, we internally execute ListCollections() as a legacy // OP_QUERY against the system.namespaces collection. Command monitoring upconversions // translate this to a "find" command rather than "listCollections". cmdMonitoringCmdName := "listCollections" if mtest.CompareServerVersions(mtest.ServerVersion(), "3.0") < 0 { cmdMonitoringCmdName = "find" } mt.Run("batch size", func(mt mtest.T) { // Create two new collections so there will be three total. createCollections(mt, 2) mt.ClearEvents() lcOpts := options.ListCollections().SetBatchSize(2) _, err := mt.DB.ListCollectionNames(context.Background(), bson.D{}, lcOpts) assert.Nil(mt, err, "ListCollectionNames error: %v", err) evt := mt.GetStartedEvent() assert.Equal( mt, cmdMonitoringCmdName, evt.CommandName, "expected %q command to be sent, got %q", cmdMonitoringCmdName, evt.CommandName) _, err = evt.Command.LookupErr("cursor", "batchSize") assert.Nil(mt, err, "expected command %s to contain key 'batchSize'", evt.Command) }) mt.RunOpts("authorizedCollections", mtest.NewOptions().MinServerVersion("4.0"), func(mt mtest.T) { mt.ClearEvents() lcOpts := options.ListCollections().SetAuthorizedCollections(true) _, err := mt.DB.ListCollections(context.Background(), bson.D{}, lcOpts) assert.Nil(mt, err, "ListCollections error: %v", err) evt := mt.GetStartedEvent() assert.Equal(mt, "listCollections", evt.CommandName, "expected 'listCollections' command to be sent, got %q", evt.CommandName) _, err = evt.Command.LookupErr("authorizedCollections") assert.Nil(mt, err, "expected command to contain key 'authorizedCollections'") }) mt.Run("getMore commands are monitored", func(mt mtest.T) { createCollections(mt, 2) assertGetMoreCommandsAreMonitored(mt, cmdMonitoringCmdName, func() (mongo.Cursor, error) { return mt.DB.ListCollections(context.Background(), bson.D{}, options.ListCollections().SetBatchSize(2)) }) }) mt.Run("killCursors commands are monitored", func(mt mtest.T) { createCollections(mt, 2) assertKillCursorsCommandsAreMonitored(mt, cmdMonitoringCmdName, func() (mongo.Cursor, error) { return mt.DB.ListCollections(context.Background(), bson.D{}, options.ListCollections().SetBatchSize(2)) }) }) }) mt.RunOpts("list collection specifications", noClientOpts, func(mt mtest.T) { mt.Run("filter passed to listCollections", func(mt mtest.T) { // Test that ListCollectionSpecifications correctly uses the supplied filter. cappedName := "list-collection-specs-capped" mt.CreateCollection(mtest.Collection{ Name: cappedName, CreateOpts: options.CreateCollection().SetCapped(true).SetSizeInBytes(4096), }, true) filter := bson.M{ "options.capped": true, } cursor, err := mt.DB.ListCollections(context.Background(), filter) assert.Nil(mt, err, "ListCollections error: %v", err) defer cursor.Close(context.Background()) assert.True(mt, cursor.Next(context.Background()), "expected Next to return true, got false; cursor error: %v", cursor.Err()) optionsDoc := bsoncore.NewDocumentBuilder(). AppendBoolean("capped", true). AppendInt32("size", 4096). Build() expectedSpec := &mongo.CollectionSpecification{ Name: cappedName, Type: "collection", ReadOnly: false, Options: bson.Raw(optionsDoc), } if mtest.CompareServerVersions(mtest.ServerVersion(), "3.6") >= 0 { uuidSubtype, uuidData := cursor.Current.Lookup("info", "uuid").Binary() expectedSpec.UUID = &primitive.Binary{Subtype: uuidSubtype, Data: uuidData} } if mtest.CompareServerVersions(mtest.ServerVersion(), "3.4") >= 0 { keysDoc := bsoncore.NewDocumentBuilder(). AppendInt32("_id", 1). Build() expectedSpec.IDIndex = &mongo.IndexSpecification{ Name: "_id_", Namespace: mt.DB.Name() + "." + cappedName, KeysDocument: bson.Raw(keysDoc), Version: 2, } } specs, err := mt.DB.ListCollectionSpecifications(context.Background(), filter) assert.Nil(mt, err, "ListCollectionSpecifications error: %v", err) assert.Equal(mt, 1, len(specs), "expected 1 CollectionSpecification, got %d", len(specs)) assert.Equal(mt, expectedSpec, specs[0], "expected specification %v, got %v", expectedSpec, specs[0]) }) mt.RunOpts("options passed to listCollections", mtest.NewOptions().MinServerVersion("3.0"), func(mt mtest.T) { // Test that ListCollectionSpecifications correctly uses the supplied options. opts := options.ListCollections().SetNameOnly(true) _, err := mt.DB.ListCollectionSpecifications(context.Background(), bson.D{}, opts) assert.Nil(mt, err, "ListCollectionSpecifications error: %v", err) evt := mt.GetStartedEvent() assert.Equal(mt, "listCollections", evt.CommandName, "expected %q command to be sent, got %q", "listCollections", evt.CommandName) nameOnly, ok := evt.Command.Lookup("nameOnly").BooleanOK() assert.True(mt, ok, "expected command %v to contain %q field", evt.Command, "nameOnly") assert.True(mt, nameOnly, "expected nameOnly value to be true, got false") }) }) mt.RunOpts("run command cursor", noClientOpts, func(mt mtest.T) { var data []interface{} for i := 0; i < 5; i++ { data = append(data, bson.D{{"x", i}}) } findCollName := "runcommandcursor_find" findCmd := bson.D{{"find", findCollName}} aggCollName := "runcommandcursor_agg" aggCmd := bson.D{ {"aggregate", aggCollName}, {"pipeline", bson.A{}}, {"cursor", bson.D{}}, } pingCmd := bson.D{{"ping", 1}} pingErr := errors.New("database response does not contain a cursor; try using RunCommand instead") testCases := []struct { name string collName string cmd interface{} toInsert []interface{} expectedErr error numExpected int minVersion string }{ {"success find", findCollName, findCmd, data, nil, 5, "3.2"}, {"success aggregate", aggCollName, aggCmd, data, nil, 5, ""}, {"failures", "runcommandcursor_ping", pingCmd, nil, pingErr, 0, ""}, } for _, tc := range testCases { tcOpts := mtest.NewOptions().CollectionName(tc.collName) if tc.minVersion != "" { tcOpts.MinServerVersion(tc.minVersion) } mt.RunOpts(tc.name, tcOpts, func(mt mtest.T) { if len(tc.toInsert) > 0 { _, err := mt.Coll.InsertMany(context.Background(), tc.toInsert) assert.Nil(mt, err, "InsertMany error: %v", err) } cursor, err := mt.DB.RunCommandCursor(context.Background(), tc.cmd) assert.Equal(mt, tc.expectedErr, err, "expected error %v, got %v", tc.expectedErr, err) if tc.expectedErr != nil { return } var count int for cursor.Next(context.Background()) { count++ } assert.Equal(mt, tc.numExpected, count, "expected document count %v, got %v", tc.numExpected, count) }) } // The find command does not exist on server versions below 3.2. cmdMonitoringMtOpts := mtest.NewOptions().MinServerVersion("3.2") mt.RunOpts("getMore commands are monitored", cmdMonitoringMtOpts, func(mt mtest.T) { initCollection(mt, mt.Coll) assertGetMoreCommandsAreMonitored(mt, "find", func() (mongo.Cursor, error) { findCmd := bson.D{ {"find", mt.Coll.Name()}, {"batchSize", 2}, } return mt.DB.RunCommandCursor(context.Background(), findCmd) }) }) mt.RunOpts("killCursors commands are monitored", cmdMonitoringMtOpts, func(mt mtest.T) { initCollection(mt, mt.Coll) assertKillCursorsCommandsAreMonitored(mt, "find", func() (mongo.Cursor, error) { findCmd := bson.D{ {"find", mt.Coll.Name()}, {"batchSize", 2}, } return mt.DB.RunCommandCursor(context.Background(), findCmd) }) }) }) mt.RunOpts("create collection", noClientOpts, func(mt mtest.T) { collectionName := "create-collection-test" mt.RunOpts("options", noClientOpts, func(mt mtest.T) { // Tests for various options combinations. The test creates a collection with some options and then verifies // the result using the options document reported by listCollections. // All possible options except collation and changeStreamPreAndPostImages. The collation is omitted here and tested below because the // collation document reported by listCollections fills in extra fields and includes a "version" field that's not described in // https://www.mongodb.com/docs/manual/reference/collation/. changeStreamPreAndPostImages is omitted here and tested in another testcase // because it is only an available option on 6.0+. storageEngine := bson.M{ "wiredTiger": bson.M{ "configString": "block_compressor=zlib", }, } defaultIndexOpts := options.DefaultIndex().SetStorageEngine(storageEngine) validator := bson.M{ "$or": bson.A{ bson.M{ "phone": bson.M{"$type": "string"}, }, bson.M{ "email": bson.M{"$type": "string"}, }, }, } nonCollationOpts := options.CreateCollection(). SetCapped(true). SetDefaultIndexOptions(defaultIndexOpts). SetMaxDocuments(100). SetSizeInBytes(1024). SetStorageEngine(storageEngine). SetValidator(validator). SetValidationAction("warn"). SetValidationLevel("moderate") nonCollationExpected := bson.M{ "capped": true, "indexOptionDefaults": bson.M{ "storageEngine": storageEngine, }, "max": int32(100), "size": int32(1024), "storageEngine": storageEngine, "validator": validator, "validationAction": "warn", "validationLevel": "moderate", } csppiOpts := options.CreateCollection().SetChangeStreamPreAndPostImages(bson.M{"enabled": true}) csppiExpected := bson.M{ "changeStreamPreAndPostImages": bson.M{ "enabled": true, }, } testCases := []struct { name string minServerVersion string maxServerVersion string createOpts options.CreateCollectionOptions expectedOpts bson.M }{ {"all options except collation and csppi", "3.2", "", nonCollationOpts, nonCollationExpected}, {"changeStreamPreAndPostImages", "6.0", "", csppiOpts, csppiExpected}, } for _, tc := range testCases { mtOpts := mtest.NewOptions(). MinServerVersion(tc.minServerVersion). MaxServerVersion(tc.maxServerVersion) mt.RunOpts(tc.name, mtOpts, func(mt mtest.T) { mt.CreateCollection(mtest.Collection{ Name: collectionName, }, false) err := mt.DB.CreateCollection(context.Background(), collectionName, tc.createOpts) assert.Nil(mt, err, "CreateCollection error: %v", err) actualOpts := getCollectionOptions(mt, collectionName) assert.Equal(mt, tc.expectedOpts, actualOpts, "options mismatch; expected %v, got %v", tc.expectedOpts, actualOpts) }) } }) mt.RunOpts("collation", mtest.NewOptions().MinServerVersion("3.4"), func(mt mtest.T) { mt.CreateCollection(mtest.Collection{ Name: collectionName, }, false) locale := "en_US" createOpts := options.CreateCollection().SetCollation(&options.Collation{ Locale: locale, }) err := mt.DB.CreateCollection(context.Background(), collectionName, createOpts) assert.Nil(mt, err, "CreateCollection error: %v", err) actualOpts := getCollectionOptions(mt, collectionName) collationVal, ok := actualOpts["collation"] assert.True(mt, ok, "expected key 'collation' in collection options %v", actualOpts) collation := collationVal.(bson.M) assert.Equal(mt, locale, collation["locale"], "expected locale %v, got %v", locale, collation["locale"]) }) mt.Run("write concern", func(mt mtest.T) { mt.CreateCollection(mtest.Collection{ Name: collectionName, }, false) err := mt.DB.CreateCollection(context.Background(), collectionName) assert.Nil(mt, err, "CreateCollection error: %v", err) evt := mt.GetStartedEvent() assert.Equal(mt, evt.CommandName, "create", "expected event for 'create', got '%v'", evt.CommandName) _, err = evt.Command.LookupErr("writeConcern") assert.Nil(mt, err, "expected write concern to be included in command %v", evt.Command) }) }) mt.RunOpts("create view", mtest.NewOptions().CreateClient(false).MinServerVersion("3.4"), func(mt mtest.T) { sourceCollectionName := "create-view-test-collection" viewName := "create-view-test-view" projectStage := bson.M{ "$project": bson.M{ "projectedField": "foo", }, } pipeline := []bson.M{projectStage} mt.Run("function parameters are translated into options", func(mt mtest.T) { mt.CreateCollection(mtest.Collection{ Name: viewName, }, false) err := mt.DB.CreateView(context.Background(), viewName, sourceCollectionName, pipeline) assert.Nil(mt, err, "CreateView error: %v", err) expectedOpts := bson.M{ "viewOn": sourceCollectionName, "pipeline": bson.A{projectStage}, } actualOpts := getCollectionOptions(mt, viewName) assert.Equal(mt, expectedOpts, actualOpts, "options mismatch; expected %v, got %v", expectedOpts, actualOpts) }) mt.Run("collation", func(mt mtest.T) { mt.CreateCollection(mtest.Collection{ Name: viewName, }, false) locale := "en_US" viewOpts := options.CreateView().SetCollation(&options.Collation{ Locale: locale, }) err := mt.DB.CreateView(context.Background(), viewName, sourceCollectionName, mongo.Pipeline{}, viewOpts) assert.Nil(mt, err, "CreateView error: %v", err) actualOpts := getCollectionOptions(mt, viewName) collationVal, ok := actualOpts["collation"] assert.True(mt, ok, "expected key 'collation' in view options %v", actualOpts) collation := collationVal.(bson.M) assert.Equal(mt, locale, collation["locale"], "expected locale %v, got %v", locale, collation["locale"]) }) }) } func getCollectionOptions(mt mtest.T, collectionName string) bson.M { mt.Helper() filter := bson.M{ "name": collectionName, } cursor, err := mt.DB.ListCollections(context.Background(), filter) assert.Nil(mt, err, "ListCollections error: %v", err) defer cursor.Close(context.Background()) assert.True(mt, cursor.Next(context.Background()), "expected Next to return true, got false") var actualOpts bson.M err = bson.UnmarshalWithRegistry(interfaceAsMapRegistry, cursor.Current.Lookup("options").Document(), &actualOpts) assert.Nil(mt, err, "UnmarshalWithRegistry error: %v", err) return actualOpts } func verifyListCollections(cursor mongo.Cursor, cappedOnly bool) error { var cappedFound, uncappedFound bool for cursor.Next(context.Background()) { nameElem, err := cursor.Current.LookupErr("name") if err != nil { return fmt.Errorf("name element not found in document %v", cursor.Current) } if nameElem.Type != bson.TypeString { return fmt.Errorf("expected name type %v, got %v", bson.TypeString, nameElem.Type) } name := nameElem.StringValue() // legacy servers can return an indexes collection that shouldn't be considered here if name != listCollUncapped && name != listCollCapped { continue } if name == listCollUncapped && !uncappedFound { if cappedOnly { return fmt.Errorf("found uncapped collection %v but expected only capped collections", listCollUncapped) } uncappedFound = true continue } if name == listCollCapped && !cappedFound { cappedFound = true continue } // duplicate found return fmt.Errorf("found duplicate collection %v", name) } if !cappedFound { return fmt.Errorf("capped collection %v not found", listCollCapped) } if !cappedOnly && !uncappedFound { return fmt.Errorf("uncapped collection %v not found", listCollUncapped) } return nil }	23.48 KB	2025-05-25 12:27
📄 errors_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 //go:build go1.13 // +build go1.13 package integration import ( "context" "errors" "fmt" "io" "net" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/integtest" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/x/mongo/driver" "go.mongodb.org/mongo-driver/x/mongo/driver/topology" ) type netErr struct { timeout bool } func (n netErr) Error() string { return "error" } func (n netErr) Timeout() bool { return n.timeout } func (n netErr) Temporary() bool { return false } var _ net.Error = (netErr)(nil) func TestErrors(t testing.T) { mt := mtest.New(t, noClientOpts) mt.RunOpts("errors are wrapped", noClientOpts, func(mt mtest.T) { mt.Run("network error during application operation", func(mt mtest.T) { ctx, cancel := context.WithCancel(context.Background()) cancel() err := mt.Client.Ping(ctx, mtest.PrimaryRp) assert.True(mt, errors.Is(err, context.Canceled), "expected error %v, got %v", context.Canceled, err) }) authOpts := mtest.NewOptions().Auth(true).Topologies(mtest.ReplicaSet, mtest.Single).MinServerVersion("4.0") mt.RunOpts("network error during auth", authOpts, func(mt mtest.T) { mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ // Set the fail point for saslContinue rather than saslStart because the driver will use speculative // auth on 4.4+ so there won't be an explicit saslStart command. FailCommands: []string{"saslContinue"}, CloseConnection: true, }, }) clientOpts := options.Client().ApplyURI(mtest.ClusterURI()) integtest.AddTestServerAPIVersion(clientOpts) client, err := mongo.Connect(context.Background(), clientOpts) assert.Nil(mt, err, "Connect error: %v", err) defer func() { _ = client.Disconnect(context.Background()) }() // A connection getting closed should manifest as an io.EOF error. err = client.Ping(context.Background(), mtest.PrimaryRp) assert.True(mt, errors.Is(err, io.EOF), "expected error %v, got %v", io.EOF, err) }) }) mt.RunOpts("network timeouts", noClientOpts, func(mt mtest.T) { mt.Run("context timeouts return DeadlineExceeded", func(mt mtest.T) { _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"x", 1}}) assert.Nil(mt, err, "InsertOne error: %v", err) mt.ClearEvents() filter := bson.M{ "$where": "function() { sleep(1000); return false; }", } timeoutCtx, cancel := context.WithTimeout(context.Background(), 100time.Millisecond) defer cancel() _, err = mt.Coll.Find(timeoutCtx, filter) evt := mt.GetStartedEvent() assert.Equal(mt, "find", evt.CommandName, "expected command 'find', got %q", evt.CommandName) assert.True(mt, errors.Is(err, context.DeadlineExceeded), "errors.Is failure: expected error %v to be %v", err, context.DeadlineExceeded) }) mt.Run("socketTimeoutMS timeouts return network errors", func(mt mtest.T) { _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"x", 1}}) assert.Nil(mt, err, "InsertOne error: %v", err) // Reset the test client to have a 100ms socket timeout. We do this here rather than passing it in as a // test option using mt.RunOpts because that could cause the collection creation or InsertOne to fail. resetClientOpts := options.Client(). SetSocketTimeout(100 time.Millisecond) mt.ResetClient(resetClientOpts) mt.ClearEvents() filter := bson.M{ "$where": "function() { sleep(1000); return false; }", } _, err = mt.Coll.Find(context.Background(), filter) evt := mt.GetStartedEvent() assert.Equal(mt, "find", evt.CommandName, "expected command 'find', got %q", evt.CommandName) assert.False(mt, errors.Is(err, context.DeadlineExceeded), "errors.Is failure: expected error %v to not be %v", err, context.DeadlineExceeded) var netErr net.Error ok := errors.As(err, &netErr) assert.True(mt, ok, "errors.As failure: expected error %v to be a net.Error", err) assert.True(mt, netErr.Timeout(), "expected error %v to be a network timeout", err) }) }) mt.Run("ServerError", func(mt mtest.T) { matchWrapped := errors.New("wrapped err") otherWrapped := errors.New("other err") const matchCode = 100 const otherCode = 120 const label = "testError" testCases := []struct { name string err mongo.ServerError hasCode bool hasLabel bool hasMessage bool hasCodeWithMessage bool isResult bool }{ { "CommandError all true", mongo.CommandError{matchCode, "foo", []string{label}, "name", matchWrapped, nil}, true, true, true, true, true, }, { "CommandError all false", mongo.CommandError{otherCode, "bar", []string{"otherError"}, "name", otherWrapped, nil}, false, false, false, false, false, }, { "CommandError has code not message", mongo.CommandError{matchCode, "bar", []string{}, "name", nil, nil}, true, false, false, false, false, }, { "WriteException all in writeConcernError", mongo.WriteException{ &mongo.WriteConcernError{"name", matchCode, "foo", nil, nil}, nil, []string{label}, nil, }, true, true, true, true, false, }, { "WriteException all in writeError", mongo.WriteException{ nil, mongo.WriteErrors{ mongo.WriteError{0, otherCode, "bar", nil, nil}, mongo.WriteError{0, matchCode, "foo", nil, nil}, }, []string{"otherError"}, nil, }, true, false, true, true, false, }, { "WriteException all false", mongo.WriteException{ &mongo.WriteConcernError{"name", otherCode, "bar", nil, nil}, mongo.WriteErrors{ mongo.WriteError{0, otherCode, "baz", nil, nil}, }, []string{"otherError"}, nil, }, false, false, false, false, false, }, { "WriteException HasErrorCodeAndMessage false", mongo.WriteException{ &mongo.WriteConcernError{"name", matchCode, "bar", nil, nil}, mongo.WriteErrors{ mongo.WriteError{0, otherCode, "foo", nil, nil}, }, []string{"otherError"}, nil, }, true, false, true, false, false, }, { "BulkWriteException all in writeConcernError", mongo.BulkWriteException{ &mongo.WriteConcernError{"name", matchCode, "foo", nil, nil}, nil, []string{label}, }, true, true, true, true, false, }, { "BulkWriteException all in writeError", mongo.BulkWriteException{ nil, []mongo.BulkWriteError{ {mongo.WriteError{0, matchCode, "foo", nil, nil}, &mongo.InsertOneModel{}}, {mongo.WriteError{0, otherCode, "bar", nil, nil}, &mongo.InsertOneModel{}}, }, []string{"otherError"}, }, true, false, true, true, false, }, { "BulkWriteException all false", mongo.BulkWriteException{ &mongo.WriteConcernError{"name", otherCode, "bar", nil, nil}, []mongo.BulkWriteError{ {mongo.WriteError{0, otherCode, "baz", nil, nil}, &mongo.InsertOneModel{}}, }, []string{"otherError"}, }, false, false, false, false, false, }, { "BulkWriteException HasErrorCodeAndMessage false", mongo.BulkWriteException{ &mongo.WriteConcernError{"name", matchCode, "bar", nil, nil}, []mongo.BulkWriteError{ {mongo.WriteError{0, otherCode, "foo", nil, nil}, &mongo.InsertOneModel{}}, }, []string{"otherError"}, }, true, false, true, false, false, }, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { has := tc.err.HasErrorCode(matchCode) assert.Equal(mt, has, tc.hasCode, "expected HasErrorCode to return %v, got %v", tc.hasCode, has) has = tc.err.HasErrorLabel(label) assert.Equal(mt, has, tc.hasLabel, "expected HasErrorLabel to return %v, got %v", tc.hasLabel, has) // Check for full message and substring has = tc.err.HasErrorMessage("foo") assert.Equal(mt, has, tc.hasMessage, "expected HasErrorMessage to return %v, got %v", tc.hasMessage, has) has = tc.err.HasErrorMessage("fo") assert.Equal(mt, has, tc.hasMessage, "expected HasErrorMessage to return %v, got %v", tc.hasMessage, has) has = tc.err.HasErrorCodeWithMessage(matchCode, "foo") assert.Equal(mt, has, tc.hasCodeWithMessage, "expected HasErrorCodeWithMessage to return %v, got %v", tc.hasCodeWithMessage, has) has = tc.err.HasErrorCodeWithMessage(matchCode, "fo") assert.Equal(mt, has, tc.hasCodeWithMessage, "expected HasErrorCodeWithMessage to return %v, got %v", tc.hasCodeWithMessage, has) assert.Equal(mt, errors.Is(tc.err, matchWrapped), tc.isResult, "expected errors.Is result to be %v", tc.isResult) }) } mtOpts := mtest.NewOptions().MinServerVersion("4.0").Topologies(mtest.ReplicaSet) mt.RunOpts("Raw response", mtOpts, func(mt mtest.T) { mt.Run("CommandError", func(mt mtest.T) { // Mock a CommandError via failpoint with an arbitrary code. mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"find"}, ErrorCode: 123, }, }) res := mt.Coll.FindOne(context.Background(), bson.D{}) assert.NotNil(mt, res.Err(), "expected FindOne error, got nil") ce, ok := res.Err().(mongo.CommandError) assert.True(mt, ok, "expected FindOne error to be CommandError, got %T", res.Err()) // Assert that raw response exists and contains error code 123. assert.NotNil(mt, ce.Raw, "ce.Raw is nil") val, err := ce.Raw.LookupErr("code") assert.Nil(mt, err, "expected 'code' field in ce.Raw, got %v", ce.Raw) code, ok := val.AsInt64OK() assert.True(mt, ok, "expected 'code' to be int64, got %v", val) assert.Equal(mt, code, int64(123), "expected 'code' 123, got %d", code) }) mt.Run("WriteError", func(mt mtest.T) { // Mock a WriteError by inserting documents with duplicate _id fields. _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"_id", 1}}) assert.Nil(mt, err, "InsertOne error: %v", err) _, err = mt.Coll.InsertOne(context.Background(), bson.D{{"_id", 1}}) assert.NotNil(mt, err, "expected InsertOne error, got nil") we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected InsertOne error to be WriteException, got %T", err) assert.NotNil(mt, we.WriteErrors, "expected we.WriteErrors, got nil") assert.NotNil(mt, we.WriteErrors[0], "expected at least one WriteError") // Assert that raw response exists for the WriteError and contains error code 11000. raw := we.WriteErrors[0].Raw assert.NotNil(mt, raw, "Raw of WriteError is nil") val, err := raw.LookupErr("code") assert.Nil(mt, err, "expected 'code' field in Raw field, got %v", raw) code, ok := val.AsInt64OK() assert.True(mt, ok, "expected 'code' to be int64, got %v", val) assert.Equal(mt, code, int64(11000), "expected 'code' 11000, got %d", code) }) mt.Run("WriteException", func(mt mtest.T) { // Mock a WriteException via failpoint with an arbitrary WriteConcernError. mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"delete"}, WriteConcernError: &mtest.WriteConcernErrorData{ Code: 123, }, }, }) _, err := mt.Coll.DeleteMany(context.Background(), bson.D{}) assert.NotNil(mt, err, "expected DeleteMany error, got nil") we, ok := err.(mongo.WriteException) assert.True(mt, ok, "expected DeleteMany error to be WriteException, got %T", err) // Assert that raw response exists and contains error code 123. assert.NotNil(mt, we.Raw, "expected RawResponse, got nil") val, err := we.Raw.LookupErr("writeConcernError", "code") assert.Nil(mt, err, "expected 'code' field in RawResponse, got %v", we.Raw) code, ok := val.AsInt64OK() assert.True(mt, ok, "expected 'code' to be int64, got %v", val) assert.Equal(mt, code, int64(123), "expected 'code' 123, got %d", code) }) }) }) mt.Run("error helpers", func(mt mtest.T) { //IsDuplicateKeyError mt.Run("IsDuplicateKeyError", func(mt mtest.T) { testCases := []struct { name string err error result bool }{ {"CommandError true", mongo.CommandError{11000, "", nil, "blah", nil, nil}, true}, {"CommandError false", mongo.CommandError{100, "", nil, "blah", nil, nil}, false}, {"WriteError true", mongo.WriteError{0, 11000, "", nil, nil}, true}, {"WriteError false", mongo.WriteError{0, 100, "", nil, nil}, false}, { "WriteException true in writeConcernError", mongo.WriteException{ &mongo.WriteConcernError{"name", 11001, "bar", nil, nil}, mongo.WriteErrors{ mongo.WriteError{0, 100, "baz", nil, nil}, }, nil, nil, }, true, }, { "WriteException true in writeErrors", mongo.WriteException{ &mongo.WriteConcernError{"name", 100, "bar", nil, nil}, mongo.WriteErrors{ mongo.WriteError{0, 12582, "baz", nil, nil}, }, nil, nil, }, true, }, { "WriteException false", mongo.WriteException{ &mongo.WriteConcernError{"name", 16460, "bar", nil, nil}, mongo.WriteErrors{ mongo.WriteError{0, 100, "blah E11000 blah", nil, nil}, }, nil, nil, }, false, }, { "BulkWriteException true", mongo.BulkWriteException{ &mongo.WriteConcernError{"name", 100, "bar", nil, nil}, []mongo.BulkWriteError{ {mongo.WriteError{0, 16460, "blah E11000 blah", nil, nil}, &mongo.InsertOneModel{}}, }, []string{"otherError"}, }, true, }, { "BulkWriteException false", mongo.BulkWriteException{ &mongo.WriteConcernError{"name", 100, "bar", nil, nil}, []mongo.BulkWriteError{ {mongo.WriteError{0, 110, "blah", nil, nil}, &mongo.InsertOneModel{}}, }, []string{"otherError"}, }, false, }, {"wrapped error", fmt.Errorf("%w", mongo.CommandError{11000, "", nil, "blah", nil, nil}), true}, {"other error type", errors.New("foo"), false}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { res := mongo.IsDuplicateKeyError(tc.err) assert.Equal(mt, res, tc.result, "expected IsDuplicateKeyError %v, got %v", tc.result, res) }) } }) //IsNetworkError mt.Run("IsNetworkError", func(mt mtest.T) { const networkLabel = "NetworkError" const otherLabel = "other" testCases := []struct { name string err error result bool }{ {"ServerError true", mongo.CommandError{100, "", []string{networkLabel}, "blah", nil, nil}, true}, {"ServerError false", mongo.CommandError{100, "", []string{otherLabel}, "blah", nil, nil}, false}, {"wrapped error", fmt.Errorf("%w", mongo.CommandError{100, "", []string{networkLabel}, "blah", nil, nil}), true}, {"other error type", errors.New("foo"), false}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { res := mongo.IsNetworkError(tc.err) assert.Equal(mt, res, tc.result, "expected IsNetworkError %v, got %v", tc.result, res) }) } }) //IsTimeout mt.Run("IsTimeout", func(mt mtest.T) { testCases := []struct { name string err error result bool }{ {"context timeout", mongo.CommandError{ 100, "", []string{"other"}, "blah", context.DeadlineExceeded, nil}, true}, {"deadline would be exceeded", mongo.CommandError{ 100, "", []string{"other"}, "blah", driver.ErrDeadlineWouldBeExceeded, nil}, true}, {"server selection timeout", mongo.CommandError{ 100, "", []string{"other"}, "blah", topology.ErrServerSelectionTimeout, nil}, true}, {"wait queue timeout", mongo.CommandError{ 100, "", []string{"other"}, "blah", topology.WaitQueueTimeoutError{}, nil}, true}, {"ServerError NetworkTimeoutError", mongo.CommandError{ 100, "", []string{"NetworkTimeoutError"}, "blah", nil, nil}, true}, {"ServerError ExceededTimeLimitError", mongo.CommandError{ 100, "", []string{"ExceededTimeLimitError"}, "blah", nil, nil}, true}, {"ServerError false", mongo.CommandError{ 100, "", []string{"other"}, "blah", nil, nil}, false}, {"net error true", mongo.CommandError{ 100, "", []string{"other"}, "blah", netErr{true}, nil}, true}, {"net error false", netErr{false}, false}, {"wrapped error", fmt.Errorf("%w", mongo.CommandError{ 100, "", []string{"other"}, "blah", context.DeadlineExceeded, nil}), true}, {"other error", errors.New("foo"), false}, } for _, tc := range testCases { mt.Run(tc.name, func(mt *mtest.T) { res := mongo.IsTimeout(tc.err) assert.Equal(mt, res, tc.result, "expected IsTimeout %v, got %v", tc.result, res) }) } }) }) }	17.26 KB	2025-05-25 12:27
📄 gridfs_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "bytes" "context" "io" "math/rand" "runtime" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/israce" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/gridfs" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" ) func TestGridFS(x testing.T) { mt := mtest.New(x, noClientOpts) mt.Run("skipping download", func(mt mtest.T) { data := []byte("abc.def.ghi") var chunkSize int32 = 4 testcases := []struct { name string read int skip int64 expectedSkipN int64 expectedSkipErr error expectedRemaining int }{ { "read 0, skip 0", 0, 0, 0, nil, 11, }, { "read 0, skip to end of chunk", 0, 4, 4, nil, 7, }, { "read 0, skip 1", 0, 1, 1, nil, 10, }, { "read 1, skip to end of chunk", 1, 3, 3, nil, 7, }, { "read all, skip beyond", 11, 1, 0, nil, 0, }, { "skip all", 0, 11, 11, nil, 0, }, { "read 1, skip to last chunk", 1, 8, 8, nil, 2, }, { "read to last chunk, skip to end", 9, 2, 2, nil, 0, }, { "read to last chunk, skip beyond", 9, 4, 2, nil, 0, }, } for _, tc := range testcases { mt.Run(tc.name, func(mt mtest.T) { bucket, err := gridfs.NewBucket(mt.DB, options.GridFSBucket().SetChunkSizeBytes(chunkSize)) assert.Nil(mt, err, "NewBucket error: %v", err) ustream, err := bucket.OpenUploadStream("foo") assert.Nil(mt, err, "OpenUploadStream error: %v", err) id := ustream.FileID _, err = ustream.Write(data) assert.Nil(mt, err, "Write error: %v", err) err = ustream.Close() assert.Nil(mt, err, "Close error: %v", err) dstream, err := bucket.OpenDownloadStream(id) assert.Nil(mt, err, "OpenDownloadStream error") dst := make([]byte, tc.read) _, err = dstream.Read(dst) assert.Nil(mt, err, "Read error: %v", err) n, err := dstream.Skip(tc.skip) assert.Equal(mt, tc.expectedSkipErr, err, "expected error on Skip: %v, got %v", tc.expectedSkipErr, err) assert.Equal(mt, tc.expectedSkipN, n, "expected Skip to return: %v, got %v", tc.expectedSkipN, n) // Read the rest. dst = make([]byte, len(data)) remaining, err := dstream.Read(dst) if err != nil { assert.Equal(mt, err, io.EOF, "unexpected Read error: %v", err) } assert.Equal(mt, tc.expectedRemaining, remaining, "expected remaining data to be: %v, got %v", tc.expectedRemaining, remaining) }) } }) mt.Run("index creation", func(mt mtest.T) { // Unit tests showing that UploadFromStream creates indexes on the chunks and files collections. bucket, err := gridfs.NewBucket(mt.DB) assert.Nil(mt, err, "NewBucket error: %v", err) err = bucket.SetWriteDeadline(time.Now().Add(5 * time.Second)) assert.Nil(mt, err, "SetWriteDeadline error: %v", err) byteData := []byte("Hello, world!") r := bytes.NewReader(byteData) _, err = bucket.UploadFromStream("filename", r) assert.Nil(mt, err, "UploadFromStream error: %v", err) findCtx, cancel := context.WithTimeout(context.Background(), 5time.Second) defer cancel() findIndex(findCtx, mt, mt.DB.Collection("fs.files"), false, "key", "filename") findIndex(findCtx, mt, mt.DB.Collection("fs.chunks"), true, "key", "files_id") }) // should not create a new index if index is numerically the same mt.Run("equivalent indexes", func(mt mtest.T) { tests := []struct { name string filesIndex bson.D chunksIndex bson.D newIndexes bool }{ { "numerically equal", bson.D{ {"key", bson.D{{"filename", float64(1.0)}, {"uploadDate", float64(1.0)}}}, {"name", "filename_1_uploadDate_1"}, }, bson.D{ {"key", bson.D{{"files_id", float64(1.0)}, {"n", float64(1.0)}}}, {"name", "files_id_1_n_1"}, {"unique", true}, }, false, }, { "numerically inequal", bson.D{ {"key", bson.D{{"filename", float64(-1.0)}, {"uploadDate", float64(1.0)}}}, {"name", "filename_-1_uploadDate_1"}, }, bson.D{ {"key", bson.D{{"files_id", float64(1.0)}, {"n", float64(-1.0)}}}, {"name", "files_id_1_n_-1"}, {"unique", true}, }, true, }, } for _, test := range tests { mt.Run(test.name, func(mt mtest.T) { mt.Run("OpenUploadStream", func(mt mtest.T) { // add indexes with floats to collections manually res := mt.DB.RunCommand(context.Background(), bson.D{ {"createIndexes", "fs.files"}, {"indexes", bson.A{ test.filesIndex, }}, }, ) assert.Nil(mt, res.Err(), "createIndexes error: %v", res.Err()) res = mt.DB.RunCommand(context.Background(), bson.D{ {"createIndexes", "fs.chunks"}, {"indexes", bson.A{ test.chunksIndex, }}, }, ) assert.Nil(mt, res.Err(), "createIndexes error: %v", res.Err()) mt.ClearEvents() bucket, err := gridfs.NewBucket(mt.DB) assert.Nil(mt, err, "NewBucket error: %v", err) defer func() { _ = bucket.Drop() }() _, err = bucket.OpenUploadStream("filename") assert.Nil(mt, err, "OpenUploadStream error: %v", err) mt.FilterStartedEvents(func(evt event.CommandStartedEvent) bool { return evt.CommandName == "createIndexes" }) evt := mt.GetStartedEvent() if test.newIndexes { if evt == nil { mt.Fatalf("expected createIndexes events but got none") } } else { if evt != nil { mt.Fatalf("expected no createIndexes events but got %v", evt.Command) } } }) mt.Run("UploadFromStream", func(mt mtest.T) { // add indexes with floats to collections manually res := mt.DB.RunCommand(context.Background(), bson.D{ {"createIndexes", "fs.files"}, {"indexes", bson.A{ test.filesIndex, }}, }, ) assert.Nil(mt, res.Err(), "createIndexes error: %v", res.Err()) res = mt.DB.RunCommand(context.Background(), bson.D{ {"createIndexes", "fs.chunks"}, {"indexes", bson.A{ test.chunksIndex, }}, }, ) assert.Nil(mt, res.Err(), "createIndexes error: %v", res.Err()) mt.ClearEvents() var fileContent []byte bucket, err := gridfs.NewBucket(mt.DB) assert.Nil(mt, err, "NewBucket error: %v", err) defer func() { _ = bucket.Drop() }() _, err = bucket.UploadFromStream("filename", bytes.NewBuffer(fileContent)) assert.Nil(mt, err, "UploadFromStream error: %v", err) mt.FilterStartedEvents(func(evt event.CommandStartedEvent) bool { return evt.CommandName == "createIndexes" }) evt := mt.GetStartedEvent() if test.newIndexes { if evt == nil { mt.Fatalf("expected createIndexes events but got none") } } else { if evt != nil { mt.Fatalf("expected no createIndexes events but got %v", evt.Command) } } }) }) } }) mt.RunOpts("download", noClientOpts, func(mt mtest.T) { mt.RunOpts("get file data", noClientOpts, func(mt mtest.T) { // Tests for the DownloadStream.GetFile method. fileName := "get-file-data-test" fileData := []byte{1, 2, 3, 4} fileMetadata := bson.D{{"k1", "v1"}, {"k2", "v2"}} rawMetadata, err := bson.Marshal(fileMetadata) assert.Nil(mt, err, "Marshal error: %v", err) uploadOpts := options.GridFSUpload().SetMetadata(fileMetadata) testCases := []struct { name string fileID interface{} }{ {"default ID", nil}, {"custom ID type", "customID"}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { // Create a new GridFS bucket. bucket, err := gridfs.NewBucket(mt.DB) assert.Nil(mt, err, "NewBucket error: %v", err) defer func() { _ = bucket.Drop() }() // Upload the file and store the uploaded file ID. uploadedFileID := tc.fileID dataReader := bytes.NewReader(fileData) if uploadedFileID == nil { uploadedFileID, err = bucket.UploadFromStream(fileName, dataReader, uploadOpts) } else { err = bucket.UploadFromStreamWithID(tc.fileID, fileName, dataReader, uploadOpts) } assert.Nil(mt, err, "error uploading file: %v", err) // The uploadDate field is calculated when the upload is complete. Manually fetch it from the // fs.files collection to use in assertions. filesColl := mt.DB.Collection("fs.files") uploadedFileDoc, err := filesColl.FindOne(context.Background(), bson.D{}).Raw() assert.Nil(mt, err, "FindOne error: %v", err) uploadTime := uploadedFileDoc.Lookup("uploadDate").Time().UTC() expectedFile := &gridfs.File{ ID: uploadedFileID, Length: int64(len(fileData)), ChunkSize: gridfs.DefaultChunkSize, UploadDate: uploadTime, Name: fileName, Metadata: rawMetadata, } // For both methods that create a DownloadStream, open a stream and compare the file given by the // stream to the expected File object. mt.RunOpts("OpenDownloadStream", noClientOpts, func(mt mtest.T) { downloadStream, err := bucket.OpenDownloadStream(uploadedFileID) assert.Nil(mt, err, "OpenDownloadStream error: %v", err) actualFile := downloadStream.GetFile() assert.Equal(mt, expectedFile, actualFile, "expected file %v, got %v", expectedFile, actualFile) }) mt.RunOpts("OpenDownloadStreamByName", noClientOpts, func(mt mtest.T) { downloadStream, err := bucket.OpenDownloadStreamByName(fileName) assert.Nil(mt, err, "OpenDownloadStream error: %v", err) actualFile := downloadStream.GetFile() assert.Equal(mt, expectedFile, actualFile, "expected file %v, got %v", expectedFile, actualFile) }) }) } }) mt.Run("chunk size determined by files collection document", func(mt mtest.T) { // Test that the chunk size for a file download is determined by the chunkSize field in the files // collection document, not the bucket's chunk size. bucket, err := gridfs.NewBucket(mt.DB) assert.Nil(mt, err, "NewBucket error: %v", err) defer func() { _ = bucket.Drop() }() fileData := []byte("hello world") uploadOpts := options.GridFSUpload().SetChunkSizeBytes(4) fileID, err := bucket.UploadFromStream("file", bytes.NewReader(fileData), uploadOpts) assert.Nil(mt, err, "UploadFromStream error: %v", err) // If the bucket's chunk size was used, this would error because the actual chunk size is 4 and the bucket // chunk size is 255 KB. var downloadBuffer bytes.Buffer _, err = bucket.DownloadToStream(fileID, &downloadBuffer) assert.Nil(mt, err, "DownloadToStream error: %v", err) downloadedBytes := downloadBuffer.Bytes() assert.Equal(mt, fileData, downloadedBytes, "expected bytes %s, got %s", fileData, downloadedBytes) }) mt.Run("error if files collection document does not have a chunkSize field", func(mt mtest.T) { // Test that opening a download returns ErrMissingChunkSize if the files collection document has no // chunk size field. oid := primitive.NewObjectID() filesDoc := bson.D{ {"_id", oid}, {"length", 10}, {"filename", "filename"}, } _, err := mt.DB.Collection("fs.files").InsertOne(context.Background(), filesDoc) assert.Nil(mt, err, "InsertOne error for files collection: %v", err) bucket, err := gridfs.NewBucket(mt.DB) assert.Nil(mt, err, "NewBucket error: %v", err) defer func() { _ = bucket.Drop() }() _, err = bucket.OpenDownloadStream(oid) assert.Equal(mt, gridfs.ErrMissingChunkSize, err, "expected error %v, got %v", gridfs.ErrMissingChunkSize, err) }) mt.Run("cursor error during read after downloading", func(mt mtest.T) { // To simulate a cursor error we upload a file larger than the 16MB default batch size, // so the underlying cursor remains open on the server. Since the ReadDeadline is // set in the past, Read should cause a timeout. fileName := "read-error-test" fileData := make([]byte, 17000000) bucket, err := gridfs.NewBucket(mt.DB) assert.Nil(mt, err, "NewBucket error: %v", err) defer func() { _ = bucket.Drop() }() dataReader := bytes.NewReader(fileData) _, err = bucket.UploadFromStream(fileName, dataReader) assert.Nil(mt, err, "UploadFromStream error: %v", err) ds, err := bucket.OpenDownloadStreamByName(fileName) assert.Nil(mt, err, "OpenDownloadStreamByName error: %v", err) err = ds.SetReadDeadline(time.Now().Add(-1 time.Second)) assert.Nil(mt, err, "SetReadDeadline error: %v", err) p := make([]byte, len(fileData)) _, err = ds.Read(p) assert.NotNil(mt, err, "expected error from Read, got nil") assert.True(mt, mongo.IsTimeout(err), "expected error to be a timeout, got %v", err.Error()) }) mt.Run("cursor error during skip after downloading", func(mt mtest.T) { // To simulate a cursor error we upload a file larger than the 16MB default batch size, // so the underlying cursor remains open on the server. Since the ReadDeadline is // set in the past, Skip should cause a timeout. fileName := "skip-error-test" fileData := make([]byte, 17000000) bucket, err := gridfs.NewBucket(mt.DB) assert.Nil(mt, err, "NewBucket error: %v", err) defer func() { _ = bucket.Drop() }() dataReader := bytes.NewReader(fileData) _, err = bucket.UploadFromStream(fileName, dataReader) assert.Nil(mt, err, "UploadFromStream error: %v", err) ds, err := bucket.OpenDownloadStreamByName(fileName) assert.Nil(mt, err, "OpenDownloadStreamByName error: %v", err) err = ds.SetReadDeadline(time.Now().Add(-1 time.Second)) assert.Nil(mt, err, "SetReadDeadline error: %v", err) _, err = ds.Skip(int64(len(fileData))) assert.NotNil(mt, err, "expected error from Skip, got nil") assert.True(mt, mongo.IsTimeout(err), "expected error to be a timeout, got %v", err.Error()) }) }) mt.RunOpts("bucket collection accessors", noClientOpts, func(mt mtest.T) { // Tests for the GetFilesCollection and GetChunksCollection accessors. fileData := []byte{1, 2, 3, 4} var chunkSize int32 = 2 testCases := []struct { name string bucketName string // defaults to "fs" }{ {"default bucket name", ""}, {"custom bucket name", "bucket"}, } for _, tc := range testCases { mt.Run(tc.name, func(mt mtest.T) { bucketOpts := options.GridFSBucket().SetChunkSizeBytes(chunkSize) if tc.bucketName != "" { bucketOpts.SetName(tc.bucketName) } bucket, err := gridfs.NewBucket(mt.DB, bucketOpts) assert.Nil(mt, err, "NewBucket error: %v", err) defer func() { _ = bucket.Drop() }() _, err = bucket.UploadFromStream("accessors-test-file", bytes.NewReader(fileData)) assert.Nil(mt, err, "UploadFromStream error: %v", err) bucketName := tc.bucketName if bucketName == "" { bucketName = "fs" } assertGridFSCollectionState(mt, bucket.GetFilesCollection(), bucketName+".files", 1) assertGridFSCollectionState(mt, bucket.GetChunksCollection(), bucketName+".chunks", 2) }) } }) mt.RunOpts("round trip", mtest.NewOptions().MaxServerVersion("3.6"), func(mt mtest.T) { skipRoundTripTest(mt) oneK := 1024 smallBuffSize := 100 tests := []struct { name string chunkSize int // make -1 for no capacity for no chunkSize fileSize int bufSize int // make -1 for no capacity for no bufSize }{ {"RoundTrip: original", -1, oneK, -1}, {"RoundTrip: chunk size multiple of file", oneK, oneK 16, -1}, {"RoundTrip: chunk size is file size", oneK, oneK, -1}, {"RoundTrip: chunk size multiple of file size and with strict buffer size", oneK, oneK * 16, smallBuffSize}, {"RoundTrip: chunk size multiple of file size and buffer size", oneK, oneK * 16, oneK * 16}, {"RoundTrip: chunk size, file size, buffer size all the same", oneK, oneK, oneK}, } for _, test := range tests { mt.Run(test.name, func(mt mtest.T) { var chunkSize int32 var temp int32 if test.chunkSize != -1 { temp = int32(test.chunkSize) chunkSize = &temp } bucket, err := gridfs.NewBucket(mt.DB, &options.BucketOptions{ ChunkSizeBytes: chunkSize, }) assert.Nil(mt, err, "NewBucket error: %v", err) timeout := 5 * time.Second if israce.Enabled { timeout = 20 * time.Second // race detector causes 2-20x slowdown } err = bucket.SetWriteDeadline(time.Now().Add(timeout)) assert.Nil(mt, err, "SetWriteDeadline error: %v", err) // Test that Upload works when the buffer to write is longer than the upload stream's internal buffer. // This requires multiple calls to uploadChunks. size := test.fileSize p := make([]byte, size) for i := 0; i < size; i++ { p[i] = byte(rand.Intn(100)) } _, err = bucket.UploadFromStream("filename", bytes.NewReader(p)) assert.Nil(mt, err, "UploadFromStream error: %v", err) var w bytes.Buffer if test.bufSize == -1 { w = bytes.NewBuffer(make([]byte, 0)) } else { w = bytes.NewBuffer(make([]byte, 0, test.bufSize)) } _, err = bucket.DownloadToStreamByName("filename", w) assert.Nil(mt, err, "DownloadToStreamByName error: %v", err) assert.Equal(mt, p, w.Bytes(), "downloaded file did not match p") }) } }) // Regression test for a bug introduced in GODRIVER-2346. mt.Run("Find", func(mt mtest.T) { bucket, err := gridfs.NewBucket(mt.DB) assert.Nil(mt, err, "NewBucket error: %v", err) // Find the file back. cursor, err := bucket.Find(bson.D{{"foo", "bar"}}) defer func() { _ = cursor.Close(context.Background()) }() assert.Nil(mt, err, "Find error: %v", err) }) } func assertGridFSCollectionState(mt mtest.T, coll mongo.Collection, expectedName string, expectedNumDocuments int64) { mt.Helper() assert.Equal(mt, expectedName, coll.Name(), "expected collection name %v, got %v", expectedName, coll.Name()) count, err := coll.CountDocuments(context.Background(), bson.D{}) assert.Nil(mt, err, "CountDocuments error: %v", err) assert.Equal(mt, expectedNumDocuments, count, "expected %d documents in collection, got %d", expectedNumDocuments, count) } func findIndex(ctx context.Context, mt mtest.T, coll mongo.Collection, unique bool, keys ...string) { mt.Helper() cur, err := coll.Indexes().List(ctx) assert.Nil(mt, err, "Indexes List error: %v", err) foundIndex := false for cur.Next(ctx) { if _, err := cur.Current.LookupErr(keys...); err == nil { if uVal, err := cur.Current.LookupErr("unique"); (unique && err == nil && uVal.Boolean() == true) \|\| (!unique && (err != nil \|\| uVal.Boolean() == false)) { foundIndex = true } } } assert.True(mt, foundIndex, "index %v not found", keys) } func skipRoundTripTest(mt *mtest.T) { if runtime.GOOS != "darwin" { return } var serverStatus bson.Raw err := mt.DB.RunCommand( context.Background(), bson.D{{"serverStatus", 1}}, ).Decode(&serverStatus) assert.Nil(mt, err, "serverStatus error %v", err) // can run on non-sharded clusters or on sharded cluster with auth/ssl disabled _, err = serverStatus.LookupErr("sharding") if err != nil { return } _, err = serverStatus.LookupErr("security") if err != nil { return } mt.Skip("skipping round trip test") }	19.3 KB	2025-05-25 12:27
📄 handshake_test.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "os" "reflect" "runtime" "testing" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/handshake" "go.mongodb.org/mongo-driver/internal/require" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/version" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" "go.mongodb.org/mongo-driver/x/mongo/driver/wiremessage" ) func TestHandshakeProse(t testing.T) { mt := mtest.New(t) if len(os.Getenv("DOCKER_RUNNING")) > 0 { t.Skip("These tests gives different results when run in Docker due to extra environment data.") } opts := mtest.NewOptions(). CreateCollection(false). ClientType(mtest.Proxy) clientMetadata := func(env bson.D) bson.D { elems := bson.D{ {Key: "driver", Value: bson.D{ {Key: "name", Value: "mongo-go-driver"}, {Key: "version", Value: version.Driver}, }}, {Key: "os", Value: bson.D{ {Key: "type", Value: runtime.GOOS}, {Key: "architecture", Value: runtime.GOARCH}, }}, } elems = append(elems, bson.E{Key: "platform", Value: runtime.Version()}) // If env is empty, don't include it in the metadata. if env != nil && !reflect.DeepEqual(env, bson.D{}) { elems = append(elems, bson.E{Key: "env", Value: env}) } return elems } // Reset the environment variables to avoid environment namespace // collision. t.Setenv("AWS_EXECUTION_ENV", "") t.Setenv("FUNCTIONS_WORKER_RUNTIME", "") t.Setenv("K_SERVICE", "") t.Setenv("VERCEL", "") t.Setenv("AWS_REGION", "") t.Setenv("AWS_LAMBDA_FUNCTION_MEMORY_SIZE", "") t.Setenv("FUNCTION_MEMORY_MB", "") t.Setenv("FUNCTION_TIMEOUT_SEC", "") t.Setenv("FUNCTION_REGION", "") t.Setenv("VERCEL_REGION", "") for _, test := range []struct { name string env map[string]string want bson.D }{ { name: "1. valid AWS", env: map[string]string{ "AWS_EXECUTION_ENV": "AWS_Lambda_java8", "AWS_REGION": "us-east-2", "AWS_LAMBDA_FUNCTION_MEMORY_SIZE": "1024", }, want: clientMetadata(bson.D{ {Key: "name", Value: "aws.lambda"}, {Key: "memory_mb", Value: 1024}, {Key: "region", Value: "us-east-2"}, }), }, { name: "2. valid Azure", env: map[string]string{ "FUNCTIONS_WORKER_RUNTIME": "node", }, want: clientMetadata(bson.D{ {Key: "name", Value: "azure.func"}, }), }, { name: "3. valid GCP", env: map[string]string{ "K_SERVICE": "servicename", "FUNCTION_MEMORY_MB": "1024", "FUNCTION_TIMEOUT_SEC": "60", "FUNCTION_REGION": "us-central1", }, want: clientMetadata(bson.D{ {Key: "name", Value: "gcp.func"}, {Key: "memory_mb", Value: 1024}, {Key: "region", Value: "us-central1"}, {Key: "timeout_sec", Value: 60}, }), }, { name: "4. valid Vercel", env: map[string]string{ "VERCEL": "1", "VERCEL_REGION": "cdg1", }, want: clientMetadata(bson.D{ {Key: "name", Value: "vercel"}, {Key: "region", Value: "cdg1"}, }), }, { name: "5. invalid multiple providers", env: map[string]string{ "AWS_EXECUTION_ENV": "AWS_Lambda_java8", "FUNCTIONS_WORKER_RUNTIME": "node", }, want: clientMetadata(nil), }, { name: "6. invalid long string", env: map[string]string{ "AWS_EXECUTION_ENV": "AWS_Lambda_java8", "AWS_REGION": func() string { var s string for i := 0; i < 512; i++ { s += "a" } return s }(), }, want: clientMetadata(bson.D{ {Key: "name", Value: "aws.lambda"}, }), }, { name: "7. invalid wrong types", env: map[string]string{ "AWS_EXECUTION_ENV": "AWS_Lambda_java8", "AWS_LAMBDA_FUNCTION_MEMORY_SIZE": "big", }, want: clientMetadata(bson.D{ {Key: "name", Value: "aws.lambda"}, }), }, { name: "8. Invalid - AWS_EXECUTION_ENV does not start with \"AWS_Lambda_\"", env: map[string]string{ "AWS_EXECUTION_ENV": "EC2", }, want: clientMetadata(nil), }, } { test := test mt.RunOpts(test.name, opts, func(mt mtest.T) { for k, v := range test.env { mt.Setenv(k, v) } // Ping the server to ensure the handshake has completed. err := mt.Client.Ping(context.Background(), nil) require.NoError(mt, err, "Ping error: %v", err) messages := mt.GetProxiedMessages() handshakeMessage := messages[:1][0] hello := handshake.LegacyHello if os.Getenv("REQUIRE_API_VERSION") == "true" { hello = "hello" } assert.Equal(mt, hello, handshakeMessage.CommandName) // Lookup the "client" field in the command document. clientVal, err := handshakeMessage.Sent.Command.LookupErr("client") require.NoError(mt, err, "expected command %s to contain client field", handshakeMessage.Sent.Command) got, ok := clientVal.DocumentOK() require.True(mt, ok, "expected client field to be a document, got %s", clientVal.Type) wantBytes, err := bson.Marshal(test.want) require.NoError(mt, err, "error marshaling want document: %v", err) want := bsoncore.Document(wantBytes) assert.Equal(mt, want, got, "want: %v, got: %v", want, got) }) } } func TestLoadBalancedConnectionHandshake(t testing.T) { mt := mtest.New(t) lbopts := mtest.NewOptions().ClientType(mtest.Proxy).Topologies( mtest.LoadBalanced) mt.RunOpts("LB connection handshake uses OP_MSG", lbopts, func(mt mtest.T) { // Ping the server to ensure the handshake has completed. err := mt.Client.Ping(context.Background(), nil) require.NoError(mt, err, "Ping error: %v", err) messages := mt.GetProxiedMessages() handshakeMessage := messages[:1][0] // Per the specifications, if loadBalanced=true, drivers MUST use the hello // command for the initial handshake and use the OP_MSG protocol. assert.Equal(mt, "hello", handshakeMessage.CommandName) assert.Equal(mt, wiremessage.OpMsg, handshakeMessage.Sent.OpCode) }) opts := mtest.NewOptions().ClientType(mtest.Proxy).Topologies( mtest.ReplicaSet, mtest.Sharded, mtest.Single, mtest.ShardedReplicaSet) mt.RunOpts("non-LB connection handshake uses OP_QUERY", opts, func(mt *mtest.T) { // Ping the server to ensure the handshake has completed. err := mt.Client.Ping(context.Background(), nil) require.NoError(mt, err, "Ping error: %v", err) messages := mt.GetProxiedMessages() handshakeMessage := messages[:1][0] want := wiremessage.OpQuery hello := handshake.LegacyHello if os.Getenv("REQUIRE_API_VERSION") == "true" { hello = "hello" // If the server API version is requested, then we should use OP_MSG // regardless of the topology want = wiremessage.OpMsg } assert.Equal(mt, hello, handshakeMessage.CommandName) assert.Equal(mt, want, handshakeMessage.Sent.OpCode) }) }	6.93 KB	2025-05-25 12:27
📄 index_view_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "errors" "testing" "time" "github.com/google/go-cmp/cmp" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/mongo/writeconcern" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) type index struct { Key bson.D Name string } func TestIndexView(t testing.T) { mt := mtest.New(t, noClientOpts) var pbool = func(b bool) bool { return &b } var pint32 = func(i int32) int32 { return &i } mt.Run("list", func(mt mtest.T) { createIndexes := func(mt mtest.T, numIndexes int) { mt.Helper() models := make([]mongo.IndexModel, 0, numIndexes) for i, key := 0, 'a'; i < numIndexes; i, key = i+1, key+1 { models = append(models, mongo.IndexModel{ Keys: bson.M{string(key): 1}, }) } _, err := mt.Coll.Indexes().CreateMany(context.Background(), models) assert.Nil(mt, err, "CreateMany error: %v", err) } // For server versions below 3.0, we internally execute List() as a legacy OP_QUERY against the system.indexes // collection. Command monitoring upconversions translate this to a "find" command rather than "listIndexes". cmdName := "listIndexes" if mtest.CompareServerVersions(mtest.ServerVersion(), "3.0") < 0 { cmdName = "find" } mt.Run("_id index is always listed", func(mt mtest.T) { verifyIndexExists(mt, mt.Coll.Indexes(), index{ Key: bson.D{{"_id", int32(1)}}, Name: "_id_", }) }) mt.Run("getMore commands are monitored", func(mt mtest.T) { createIndexes(mt, 2) assertGetMoreCommandsAreMonitored(mt, cmdName, func() (mongo.Cursor, error) { return mt.Coll.Indexes().List(context.Background(), options.ListIndexes().SetBatchSize(2)) }) }) mt.Run("killCursors commands are monitored", func(mt mtest.T) { createIndexes(mt, 2) assertKillCursorsCommandsAreMonitored(mt, cmdName, func() (mongo.Cursor, error) { return mt.Coll.Indexes().List(context.Background(), options.ListIndexes().SetBatchSize(2)) }) }) }) mt.RunOpts("create one", noClientOpts, func(mt mtest.T) { mt.Run("name not specified", func(mt mtest.T) { iv := mt.Coll.Indexes() keysDoc := bson.D{ {"foo", int32(1)}, {"bar", int32(-1)}, } expectedName := "foo_1_bar_-1" indexName, err := iv.CreateOne(context.Background(), mongo.IndexModel{ Keys: keysDoc, }) assert.Nil(mt, err, "CreateOne error: %v", err) assert.Equal(mt, expectedName, indexName, "expected name %q, got %q", expectedName, indexName) verifyIndexExists(mt, iv, index{ Key: keysDoc, Name: indexName, }) }) mt.Run("specify name", func(mt mtest.T) { iv := mt.Coll.Indexes() keysDoc := bson.D{{"foo", int32(-1)}} name := "testname" indexName, err := iv.CreateOne(context.Background(), mongo.IndexModel{ Keys: keysDoc, Options: options.Index().SetName(name), }) assert.Nil(mt, err, "CreateOne error: %v", err) assert.Equal(mt, name, indexName, "expected returned name %q, got %q", name, indexName) verifyIndexExists(mt, iv, index{ Key: keysDoc, Name: indexName, }) }) mt.Run("all options", func(mt mtest.T) { opts := options.Index(). SetBackground(false). SetExpireAfterSeconds(10). SetName("a"). SetSparse(false). SetUnique(false). SetVersion(1). SetDefaultLanguage("english"). SetLanguageOverride("english"). SetTextVersion(1). SetWeights(bson.D{}). SetSphereVersion(1). SetBits(2). SetMax(10). SetMin(1). SetPartialFilterExpression(bson.D{}). SetStorageEngine(bson.D{ {"wiredTiger", bson.D{ {"configString", "block_compressor=zlib"}, }}, }) // Only check SetBucketSize if version is less than 4.9 if mtest.CompareServerVersions(mtest.ServerVersion(), "4.9") < 0 { opts.SetBucketSize(1) } // Omits collation option because it's incompatible with version option _, err := mt.Coll.Indexes().CreateOne(context.Background(), mongo.IndexModel{ Keys: bson.D{{"foo", "text"}}, Options: opts, }) assert.Nil(mt, err, "CreateOne error: %v", err) }) mt.RunOpts("collation", mtest.NewOptions().MinServerVersion("3.4"), func(mt mtest.T) { // collation invalid for server versions < 3.4 _, err := mt.Coll.Indexes().CreateOne(context.Background(), mongo.IndexModel{ Keys: bson.D{{"bar", "text"}}, Options: options.Index().SetCollation(&options.Collation{ Locale: "simple", }), }) assert.Nil(mt, err, "CreateOne error: %v", err) }) mt.RunOpts("wildcard", mtest.NewOptions().MinServerVersion("4.1").CreateClient(false), func(mt mtest.T) { keysDoc := bson.D{{"$*", int32(1)}} mt.Run("no options", func(mt mtest.T) { iv := mt.Coll.Indexes() indexName, err := iv.CreateOne(context.Background(), mongo.IndexModel{ Keys: keysDoc, }) assert.Nil(mt, err, "CreateOne error: %v", err) verifyIndexExists(mt, iv, index{ Key: keysDoc, Name: indexName, }) }) mt.Run("wildcard projection", func(mt mtest.T) { iv := mt.Coll.Indexes() // Create an index with a wildcard projection document. The "_id: false" isn't needed to create the // index. We use the listIndexes command below to assert that the created index has this projection // document and the format of the document returned by listIndexes was changed in 4.5.x to explicitly // include "_id: false", so we include it here too. proj := bson.D{{"a", true}, {"_id", false}} _, err := iv.CreateOne(context.Background(), mongo.IndexModel{ Keys: keysDoc, Options: options.Index().SetWildcardProjection(proj), }) assert.Nil(mt, err, "CreateOne error: %v", err) indexDoc := getIndexDoc(mt, iv, keysDoc) assert.NotNil(mt, indexDoc, "expected to find keys document %v but was not found", keysDoc) checkIndexDocContains(mt, indexDoc, bson.E{ Key: "wildcardProjection", Value: proj, }) }) }) mt.RunOpts("hidden", mtest.NewOptions().MinServerVersion("4.4"), func(mt mtest.T) { iv := mt.Coll.Indexes() keysDoc := bson.D{{"x", int32(1)}} model := mongo.IndexModel{ Keys: keysDoc, Options: options.Index().SetHidden(true), } _, err := iv.CreateOne(context.Background(), model) assert.Nil(mt, err, "CreateOne error: %v", err) indexDoc := getIndexDoc(mt, iv, keysDoc) assert.NotNil(mt, indexDoc, "index with keys document %v was not found", keysDoc) checkIndexDocContains(mt, indexDoc, bson.E{ Key: "hidden", Value: true, }) }) mt.Run("nil keys", func(mt mtest.T) { _, err := mt.Coll.Indexes().CreateOne(context.Background(), mongo.IndexModel{ Keys: nil, }) assert.NotNil(mt, err, "expected CreateOne error, got nil") }) // Only run on replica sets as commitQuorum is not supported on standalones. mt.RunOpts("commit quorum", mtest.NewOptions().Topologies(mtest.ReplicaSet).CreateClient(false), func(mt mtest.T) { intVal := options.CreateIndexes().SetCommitQuorumInt(1) stringVal := options.CreateIndexes().SetCommitQuorumString("majority") majority := options.CreateIndexes().SetCommitQuorumMajority() votingMembers := options.CreateIndexes().SetCommitQuorumVotingMembers() indexModel := mongo.IndexModel{ Keys: bson.D{{"x", 1}}, } testCases := []struct { name string opts options.CreateIndexesOptions expectError bool expectedValue interface{} // ignored if expectError is true minServerVersion string maxServerVersion string }{ {"error on server versions before 4.4", majority, true, nil, "", "4.2"}, {"integer value", intVal, false, int32(1), "4.4", ""}, {"string value", stringVal, false, "majority", "4.4", ""}, {"majority", majority, false, "majority", "4.4", ""}, {"votingMembers", votingMembers, false, "votingMembers", "4.4", ""}, } for _, tc := range testCases { mtOpts := mtest.NewOptions().MinServerVersion(tc.minServerVersion).MaxServerVersion(tc.maxServerVersion) mt.RunOpts(tc.name, mtOpts, func(mt mtest.T) { mt.ClearEvents() _, err := mt.Coll.Indexes().CreateOne(context.Background(), indexModel, tc.opts) if tc.expectError { assert.NotNil(mt, err, "expected CreateOne error, got nil") return } assert.Nil(mt, err, "CreateOne error: %v", err) cmd := mt.GetStartedEvent().Command sentBSONValue, err := cmd.LookupErr("commitQuorum") assert.Nil(mt, err, "expected commitQuorum in command %s", cmd) var sentValue interface{} err = sentBSONValue.Unmarshal(&sentValue) assert.Nil(mt, err, "Unmarshal error: %v", err) assert.Equal(mt, tc.expectedValue, sentValue, "expected commitQuorum value %v, got %v", tc.expectedValue, sentValue) }) } }) unackClientOpts := options.Client(). SetWriteConcern(writeconcern.New(writeconcern.W(0))) unackMtOpts := mtest.NewOptions(). ClientOptions(unackClientOpts). MinServerVersion("3.6") mt.RunOpts("unacknowledged write", unackMtOpts, func(mt mtest.T) { _, err := mt.Coll.Indexes().CreateOne(context.Background(), mongo.IndexModel{Keys: bson.D{{"x", 1}}}) if !errors.Is(err, mongo.ErrUnacknowledgedWrite) { // Use a direct comparison rather than assert.Equal because assert.Equal will compare the error strings, // so the assertion would succeed even if the error had not been wrapped. mt.Fatalf("expected CreateOne error %v, got %v", mongo.ErrUnacknowledgedWrite, err) } }) // Needs to run on these versions for failpoints mt.RunOpts("replace error", mtest.NewOptions().Topologies(mtest.ReplicaSet).MinServerVersion("4.0"), func(mt mtest.T) { mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: "alwaysOn", Data: mtest.FailPointData{ FailCommands: []string{"createIndexes"}, ErrorCode: 100, }, }) _, err := mt.Coll.Indexes().CreateOne(context.Background(), mongo.IndexModel{Keys: bson.D{{"x", 1}}}) assert.NotNil(mt, err, "expected CreateOne error, got nil") cmdErr, ok := err.(mongo.CommandError) assert.True(mt, ok, "expected mongo.CommandError, got %T", err) assert.Equal(mt, int32(100), cmdErr.Code, "expected error code 100, got %v", cmdErr.Code) }) mt.Run("multi-key map", func(mt mtest.T) { iv := mt.Coll.Indexes() _, err := iv.CreateOne(context.Background(), mongo.IndexModel{ Keys: bson.M{"foo": 1, "bar": -1}, }) assert.NotNil(mt, err, "expected CreateOne error, got nil") assert.Equal(mt, mongo.ErrMapForOrderedArgument{"keys"}, err, "expected error %v, got %v", mongo.ErrMapForOrderedArgument{"key"}, err) }) mt.Run("single key map", func(mt mtest.T) { iv := mt.Coll.Indexes() expectedName := "foo_1" indexName, err := iv.CreateOne(context.Background(), mongo.IndexModel{ Keys: bson.M{"foo": 1}, }) assert.Nil(mt, err, "CreateOne error: %v", err) assert.Equal(mt, expectedName, indexName, "expected name %q, got %q", expectedName, indexName) verifyIndexExists(mt, iv, index{ Key: bson.D{{"foo", int32(1)}}, Name: indexName, }) }) }) mt.Run("create many", func(mt mtest.T) { mt.Run("success", func(mt mtest.T) { iv := mt.Coll.Indexes() firstKeysDoc := bson.D{{"foo", int32(-1)}} secondKeysDoc := bson.D{{"bar", int32(1)}, {"baz", int32(-1)}} expectedNames := []string{"foo_-1", "bar_1_baz_-1"} indexNames, err := iv.CreateMany(context.Background(), []mongo.IndexModel{ { Keys: firstKeysDoc, }, { Keys: secondKeysDoc, }, }) assert.Nil(mt, err, "CreateMany error: %v", err) assert.Equal(mt, expectedNames, indexNames, "expected returned names %v, got %v", expectedNames, indexNames) verifyIndexExists(mt, iv, index{ Key: firstKeysDoc, Name: indexNames[0], }) verifyIndexExists(mt, iv, index{ Key: secondKeysDoc, Name: indexNames[1], }) }) wc := writeconcern.New(writeconcern.W(1)) wcMtOpts := mtest.NewOptions().CollectionOptions(options.Collection().SetWriteConcern(wc)) mt.RunOpts("uses writeconcern", wcMtOpts, func(mt mtest.T) { iv := mt.Coll.Indexes() _, err := iv.CreateMany(context.Background(), []mongo.IndexModel{ { Keys: bson.D{{"foo", -1}}, }, { Keys: bson.D{{"bar", 1}, {"baz", -1}}, }, }) assert.Nil(mt, err, "CreateMany error: %v", err) evt := mt.GetStartedEvent() assert.NotNil(mt, evt, "expected CommandStartedEvent, got nil") assert.Equal(mt, "createIndexes", evt.CommandName, "command name mismatch; expected createIndexes, got %s", evt.CommandName) actual, err := evt.Command.LookupErr("writeConcern", "w") assert.Nil(mt, err, "error getting writeConcern.w: %s", err) wcVal := numberFromValue(mt, actual) assert.Equal(mt, int64(1), wcVal, "expected writeConcern to be 1, got: %v", wcVal) }) // Only run on replica sets as commitQuorum is not supported on standalones. mt.RunOpts("commit quorum", mtest.NewOptions().Topologies(mtest.ReplicaSet).CreateClient(false), func(mt mtest.T) { intVal := options.CreateIndexes().SetCommitQuorumInt(1) stringVal := options.CreateIndexes().SetCommitQuorumString("majority") majority := options.CreateIndexes().SetCommitQuorumMajority() votingMembers := options.CreateIndexes().SetCommitQuorumVotingMembers() indexModel1 := mongo.IndexModel{ Keys: bson.D{{"x", 1}}, } indexModel2 := mongo.IndexModel{ Keys: bson.D{{"y", 1}}, } testCases := []struct { name string opts options.CreateIndexesOptions expectError bool expectedValue interface{} // ignored if expectError is true minServerVersion string maxServerVersion string }{ {"error on server versions before 4.4", majority, true, nil, "", "4.2"}, {"integer value", intVal, false, int32(1), "4.4", ""}, {"string value", stringVal, false, "majority", "4.4", ""}, {"majority", majority, false, "majority", "4.4", ""}, {"votingMembers", votingMembers, false, "votingMembers", "4.4", ""}, } for _, tc := range testCases { mtOpts := mtest.NewOptions().MinServerVersion(tc.minServerVersion).MaxServerVersion(tc.maxServerVersion) mt.RunOpts(tc.name, mtOpts, func(mt mtest.T) { mt.ClearEvents() _, err := mt.Coll.Indexes().CreateMany(context.Background(), []mongo.IndexModel{indexModel1, indexModel2}, tc.opts) if tc.expectError { assert.NotNil(mt, err, "expected CreateMany error, got nil") return } assert.Nil(mt, err, "CreateMany error: %v", err) cmd := mt.GetStartedEvent().Command sentBSONValue, err := cmd.LookupErr("commitQuorum") assert.Nil(mt, err, "expected commitQuorum in command %s", cmd) var sentValue interface{} err = sentBSONValue.Unmarshal(&sentValue) assert.Nil(mt, err, "Unmarshal error: %v", err) assert.Equal(mt, tc.expectedValue, sentValue, "expected commitQuorum value %v, got %v", tc.expectedValue, sentValue) }) } }) // Needs to run on these versions for failpoints mt.RunOpts("replace error", mtest.NewOptions().Topologies(mtest.ReplicaSet).MinServerVersion("4.0"), func(mt mtest.T) { mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: "alwaysOn", Data: mtest.FailPointData{ FailCommands: []string{"createIndexes"}, ErrorCode: 100, }, }) _, err := mt.Coll.Indexes().CreateMany(context.Background(), []mongo.IndexModel{ { Keys: bson.D{{"foo", int32(-1)}}, }, { Keys: bson.D{{"bar", int32(1)}, {"baz", int32(-1)}}, }, }) assert.NotNil(mt, err, "expected CreateMany error, got nil") cmdErr, ok := err.(mongo.CommandError) assert.True(mt, ok, "expected mongo.CommandError, got %T", err) assert.Equal(mt, int32(100), cmdErr.Code, "expected error code 100, got %v", cmdErr.Code) }) mt.Run("multi-key map", func(mt mtest.T) { iv := mt.Coll.Indexes() _, err := iv.CreateMany(context.Background(), []mongo.IndexModel{ { Keys: bson.M{"foo": 1, "bar": -1}, }, { Keys: bson.D{{"bar", int32(1)}, {"baz", int32(-1)}}, }, }) assert.NotNil(mt, err, "expected CreateOne error, got nil") assert.Equal(mt, mongo.ErrMapForOrderedArgument{"keys"}, err, "expected error %v, got %v", mongo.ErrMapForOrderedArgument{"keys"}, err) }) mt.Run("single key map", func(mt mtest.T) { iv := mt.Coll.Indexes() firstKeysDoc := bson.M{"foo": -1} secondKeysDoc := bson.D{{"bar", int32(1)}, {"baz", int32(-1)}} expectedNames := []string{"foo_-1", "bar_1_baz_-1"} indexNames, err := iv.CreateMany(context.Background(), []mongo.IndexModel{ { Keys: firstKeysDoc, }, { Keys: secondKeysDoc, }, }) assert.Nil(mt, err, "CreateMany error: %v", err) assert.Equal(mt, expectedNames, indexNames, "expected returned names %v, got %v", expectedNames, indexNames) verifyIndexExists(mt, iv, index{ Key: bson.D{{"foo", int32(-1)}}, Name: indexNames[0], }) verifyIndexExists(mt, iv, index{ Key: secondKeysDoc, Name: indexNames[1], }) }) }) mt.RunOpts("list specifications", noClientOpts, func(mt mtest.T) { mt.Run("verify results", func(mt mtest.T) { // Create a handful of indexes _, err := mt.Coll.Indexes().CreateMany(context.Background(), []mongo.IndexModel{ { Keys: bson.D{{"foo", int32(-1)}}, Options: options.Index().SetUnique(true), }, { Keys: bson.D{{"bar", int32(1)}}, Options: options.Index().SetExpireAfterSeconds(120), }, { Keys: bson.D{{"baz", int32(1)}}, Options: options.Index().SetSparse(true), }, { Keys: bson.D{{"bar", int32(1)}, {"baz", int32(-1)}}, }, }) assert.Nil(mt, err, "CreateMany error: %v", err) expectedSpecs := []mongo.IndexSpecification{ { Name: "_id_", Namespace: mt.DB.Name() + "." + mt.Coll.Name(), KeysDocument: bson.Raw(bsoncore.NewDocumentBuilder().AppendInt32("_id", 1).Build()), Version: 2, ExpireAfterSeconds: nil, Sparse: nil, // ID index is special and does not return 'true', despite being unique. Unique: nil, }, { Name: "foo_-1", Namespace: mt.DB.Name() + "." + mt.Coll.Name(), KeysDocument: bson.Raw(bsoncore.NewDocumentBuilder().AppendInt32("foo", -1).Build()), Version: 2, ExpireAfterSeconds: nil, Sparse: nil, Unique: pbool(true), }, { Name: "bar_1", Namespace: mt.DB.Name() + "." + mt.Coll.Name(), KeysDocument: bson.Raw(bsoncore.NewDocumentBuilder().AppendInt32("bar", 1).Build()), Version: 2, ExpireAfterSeconds: pint32(120), Sparse: nil, Unique: nil, }, { Name: "baz_1", Namespace: mt.DB.Name() + "." + mt.Coll.Name(), KeysDocument: bson.Raw(bsoncore.NewDocumentBuilder().AppendInt32("baz", 1).Build()), Version: 2, ExpireAfterSeconds: nil, Sparse: pbool(true), Unique: nil, }, { Name: "bar_1_baz_-1", Namespace: mt.DB.Name() + "." + mt.Coll.Name(), KeysDocument: bson.Raw(bsoncore.NewDocumentBuilder().AppendInt32("bar", 1).AppendInt32("baz", -1).Build()), Version: 2, ExpireAfterSeconds: nil, Sparse: nil, Unique: nil, }, } if mtest.CompareServerVersions(mtest.ServerVersion(), "3.4") < 0 { for _, expectedSpec := range expectedSpecs { expectedSpec.Version = 1 } } specs, err := mt.Coll.Indexes().ListSpecifications(context.Background()) assert.Nil(mt, err, "ListSpecifications error: %v", err) assert.Equal(mt, len(expectedSpecs), len(specs), "expected %d specification, got %d", len(expectedSpecs), len(specs)) assert.True(mt, cmp.Equal(specs, expectedSpecs), "expected specifications to match: %v", cmp.Diff(specs, expectedSpecs)) }) mt.RunOpts("options passed to listIndexes", mtest.NewOptions().MinServerVersion("3.0"), func(mt mtest.T) { opts := options.ListIndexes().SetMaxTime(100 time.Millisecond) _, err := mt.Coll.Indexes().ListSpecifications(context.Background(), opts) assert.Nil(mt, err, "ListSpecifications error: %v", err) evt := mt.GetStartedEvent() assert.Equal(mt, evt.CommandName, "listIndexes", "expected %q command to be sent, got %q", "listIndexes", evt.CommandName) maxTimeMS, ok := evt.Command.Lookup("maxTimeMS").Int64OK() assert.True(mt, ok, "expected command %v to contain %q field", evt.Command, "maxTimeMS") assert.Equal(mt, int64(100), maxTimeMS, "expected maxTimeMS value to be 100, got %d", maxTimeMS) }) }) mt.Run("drop one", func(mt mtest.T) { iv := mt.Coll.Indexes() indexNames, err := iv.CreateMany(context.Background(), []mongo.IndexModel{ { Keys: bson.D{{"foo", -1}}, }, { Keys: bson.D{{"bar", 1}, {"baz", -1}}, }, }) assert.Nil(mt, err, "CreateMany error: %v", err) assert.Equal(mt, 2, len(indexNames), "expected 2 index names, got %v", len(indexNames)) _, err = iv.DropOne(context.Background(), indexNames[1]) assert.Nil(mt, err, "DropOne error: %v", err) cursor, err := iv.List(context.Background()) assert.Nil(mt, err, "List error: %v", err) for cursor.Next(context.Background()) { var idx index err = cursor.Decode(&idx) assert.Nil(mt, err, "Decode error: %v (document %v)", err, cursor.Current) assert.NotEqual(mt, indexNames[1], idx.Name, "found index %v after dropping", indexNames[1]) } assert.Nil(mt, cursor.Err(), "cursor error: %v", cursor.Err()) }) mt.Run("drop all", func(mt mtest.T) { iv := mt.Coll.Indexes() names, err := iv.CreateMany(context.Background(), []mongo.IndexModel{ { Keys: bson.D{{"foo", -1}}, }, { Keys: bson.D{{"bar", 1}, {"baz", -1}}, }, }) assert.Nil(mt, err, "CreateMany error: %v", err) assert.Equal(mt, 2, len(names), "expected 2 index names, got %v", len(names)) _, err = iv.DropAll(context.Background()) assert.Nil(mt, err, "DropAll error: %v", err) cursor, err := iv.List(context.Background()) assert.Nil(mt, err, "List error: %v", err) for cursor.Next(context.Background()) { var idx index err = cursor.Decode(&idx) assert.Nil(mt, err, "Decode error: %v (document %v)", err, cursor.Current) assert.NotEqual(mt, names[0], idx.Name, "found index %v, after dropping", names[0]) assert.NotEqual(mt, names[1], idx.Name, "found index %v, after dropping", names[1]) } assert.Nil(mt, cursor.Err(), "cursor error: %v", cursor.Err()) }) mt.RunOpts("clustered indexes", mtest.NewOptions().MinServerVersion("5.3"), func(mt mtest.T) { const name = "clustered" clustered := mt.CreateCollection(mtest.Collection{ Name: name, CreateOpts: options.CreateCollection().SetClusteredIndex(bson.D{{"key", bson.D{{"_id", 1}}}, {"unique", true}}), }, true) mt.Run("create one", func(mt mtest.T) { _, err := clustered.Indexes().CreateOne(context.Background(), mongo.IndexModel{ Keys: bson.D{{"foo", int32(-1)}}, }) assert.Nil(mt, err, "CreateOne error: %v", err) specs, err := clustered.Indexes().ListSpecifications(context.Background()) assert.Nil(mt, err, "ListSpecifications error: %v", err) expectedSpecs := []mongo.IndexSpecification{ { Name: "_id_", Namespace: mt.DB.Name() + "." + name, KeysDocument: bson.Raw(bsoncore.NewDocumentBuilder().AppendInt32("_id", 1).Build()), Version: 2, Unique: func(b bool) bool { return &b }(true), Clustered: func(b bool) bool { return &b }(true), }, { Name: "foo_-1", Namespace: mt.DB.Name() + "." + name, KeysDocument: bson.Raw(bsoncore.NewDocumentBuilder().AppendInt32("foo", -1).Build()), Version: 2, }, } assert.True(mt, cmp.Equal(specs, expectedSpecs), "expected specifications to match: %v", cmp.Diff(specs, expectedSpecs)) }) }) } func getIndexDoc(mt mtest.T, iv mongo.IndexView, expectedKeyDoc bson.D) bson.D { c, err := iv.List(context.Background()) assert.Nil(mt, err, "List error: %v", err) for c.Next(context.Background()) { var index bson.D err = c.Decode(&index) assert.Nil(mt, err, "Decode error: %v", err) for _, elem := range index { if elem.Key != "key" { continue } if cmp.Equal(expectedKeyDoc, elem.Value.(bson.D)) { return index } } } return nil } func checkIndexDocContains(mt mtest.T, indexDoc bson.D, expectedElem bson.E) { for _, elem := range indexDoc { if elem.Key != expectedElem.Key { continue } assert.Equal(mt, expectedElem, elem, "expected element %v, got %v", expectedElem, elem) return } mt.Fatalf("no element matching %v found", expectedElem) } func verifyIndexExists(mt mtest.T, iv mongo.IndexView, expected index) { mt.Helper() cursor, err := iv.List(context.Background()) assert.Nil(mt, err, "List error: %v", err) var found bool for cursor.Next(context.Background()) { var idx index err = cursor.Decode(&idx) assert.Nil(mt, err, "Decode error: %v", err) if idx.Name == expected.Name { if expected.Key != nil { assert.Equal(mt, expected.Key, idx.Key, "key document mismatch; expected %v, got %v", expected.Key, idx.Key) } found = true } } assert.Nil(mt, cursor.Err(), "cursor error: %v", err) assert.True(mt, found, "expected to find index %v but was not found", expected.Name) }	25.49 KB	2025-05-25 12:27
📄 initial_dns_seedlist_discovery_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "crypto/tls" "io/ioutil" "os" "path" "runtime" "strings" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/description" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/mongo/readpref" "go.mongodb.org/mongo-driver/x/mongo/driver/connstring" "go.mongodb.org/mongo-driver/x/mongo/driver/topology" ) const ( seedlistDiscoveryTestsBaseDir = "../../testdata/initial-dns-seedlist-discovery" ) type seedlistTest struct { URI string `bson:"uri"` Seeds []string `bson:"seeds"` NumSeeds int `bson:"numSeeds"` Hosts []string `bson:"hosts"` NumHosts int `bson:"numHosts"` Error bool `bson:"error"` Options bson.Raw `bson:"options"` Ping bool `bson:"ping"` } func TestInitialDNSSeedlistDiscoverySpec(t testing.T) { mt := mtest.New(t, noClientOpts) mt.RunOpts("replica set", mtest.NewOptions().Topologies(mtest.ReplicaSet).CreateClient(false), func(mt mtest.T) { mt.Parallel() runSeedlistDiscoveryDirectory(mt, "replica-set") }) mt.RunOpts("sharded", mtest.NewOptions().Topologies(mtest.Sharded).CreateClient(false), func(mt mtest.T) { mt.Parallel() runSeedlistDiscoveryDirectory(mt, "sharded") }) mt.RunOpts("load balanced", mtest.NewOptions().Topologies(mtest.LoadBalanced).CreateClient(false), func(mt mtest.T) { mt.Parallel() runSeedlistDiscoveryDirectory(mt, "load-balanced") }) } func runSeedlistDiscoveryDirectory(mt mtest.T, subdirectory string) { directoryPath := path.Join(seedlistDiscoveryTestsBaseDir, subdirectory) for _, file := range jsonFilesInDir(mt, directoryPath) { mt.RunOpts(file, noClientOpts, func(mt mtest.T) { runSeedlistDiscoveryTest(mt, path.Join(directoryPath, file)) }) } } // runSeedlistDiscoveryPingTest will create a new connection using the test URI and attempt to "ping" the server. func runSeedlistDiscoveryPingTest(mt mtest.T, clientOpts options.ClientOptions) { ctx := context.Background() client, err := mongo.Connect(ctx, clientOpts) assert.Nil(mt, err, "Connect error: %v", err) defer func() { _ = client.Disconnect(ctx) }() // Create a context with a timeout to prevent the ping operation from blocking indefinitely. pingCtx, cancel := context.WithTimeout(ctx, 1time.Second) defer cancel() // Ping the server. err = client.Ping(pingCtx, readpref.Nearest()) assert.Nil(mt, err, "Ping error: %v", err) } func runSeedlistDiscoveryTest(mt mtest.T, file string) { content, err := ioutil.ReadFile(file) assert.Nil(mt, err, "ReadFile error for %v: %v", file, err) var test seedlistTest err = bson.UnmarshalExtJSONWithRegistry(specTestRegistry, content, false, &test) assert.Nil(mt, err, "UnmarshalExtJSONWithRegistry error: %v", err) if runtime.GOOS == "windows" && strings.HasSuffix(file, "/two-txt-records.json") { mt.Skip("skipping to avoid windows multiple TXT record lookup bug") } if strings.HasPrefix(runtime.Version(), "go1.11") && strings.HasSuffix(file, "/one-txt-record-multiple-strings.json") { mt.Skip("skipping to avoid go1.11 problem with multiple strings in one TXT record") } cs, err := connstring.ParseAndValidate(test.URI) if test.Error { assert.NotNil(mt, err, "expected URI parsing error, got nil") return } assert.Nil(mt, err, "ParseAndValidate error: %v", err) assert.Equal(mt, connstring.SchemeMongoDBSRV, cs.Scheme, "expected scheme %v, got %v", connstring.SchemeMongoDBSRV, cs.Scheme) // DNS records may be out of order from the test file's ordering. actualSeedlist := buildSet(cs.Hosts) // If NumSeeds is set, check number of seeds in seedlist. if test.NumSeeds != nil { assert.Equal(mt, len(actualSeedlist), test.NumSeeds, "expected %v seeds, got %v", test.NumSeeds, len(actualSeedlist)) } // If Seeds is set, check contents of seedlist. if test.Seeds != nil { expectedSeedlist := buildSet(test.Seeds) assert.Equal(mt, expectedSeedlist, actualSeedlist, "expected seedlist %v, got %v", expectedSeedlist, actualSeedlist) } verifyConnstringOptions(mt, test.Options, cs) tlsConfig := getSSLSettings(mt, test) // Make a topology from the options. opts := options.Client().ApplyURI(test.URI) if tlsConfig != nil { opts.SetTLSConfig(tlsConfig) } cfg, err := topology.NewConfig(opts, nil) assert.Nil(mt, err, "error constructing toplogy config: %v", err) topo, err := topology.New(cfg) assert.Nil(mt, err, "topology.New error: %v", err) err = topo.Connect() assert.Nil(mt, err, "topology.Connect error: %v", err) defer func() { _ = topo.Disconnect(context.Background()) }() // If NumHosts is set, check number of hosts currently stored on the Topology. if test.NumHosts != nil { actualNumHosts := len(topo.Description().Servers) assert.Equal(mt, test.NumHosts, actualNumHosts, "expected to find %v hosts, found %v", test.NumHosts, actualNumHosts) } for _, host := range test.Hosts { _, err := getServerByAddress(host, topo) assert.Nil(mt, err, "error finding host %q: %v", host, err) } if ping := test.Ping; ping == nil \|\| ping { runSeedlistDiscoveryPingTest(mt, opts) } } func buildSet(list []string) map[string]struct{} { set := make(map[string]struct{}) for _, s := range list { set[s] = struct{}{} } return set } func verifyConnstringOptions(mt mtest.T, expected bson.Raw, cs connstring.ConnString) { mt.Helper() elems, _ := expected.Elements() for _, elem := range elems { key := elem.Key() opt := elem.Value() switch key { case "replicaSet": rs := opt.StringValue() assert.Equal(mt, rs, cs.ReplicaSet, "expected replicaSet value %v, got %v", rs, cs.ReplicaSet) case "ssl": ssl := opt.Boolean() assert.Equal(mt, ssl, cs.SSL, "expected ssl value %v, got %v", ssl, cs.SSL) case "authSource": source := opt.StringValue() assert.Equal(mt, source, cs.AuthSource, "expected auth source value %v, got %v", source, cs.AuthSource) case "directConnection": dc := opt.Boolean() assert.True(mt, cs.DirectConnectionSet, "expected cs.DirectConnectionSet to be true, got false") assert.Equal(mt, dc, cs.DirectConnection, "expected cs.DirectConnection to be %v, got %v", dc, cs.DirectConnection) case "loadBalanced": lb := opt.Boolean() assert.True(mt, cs.LoadBalancedSet, "expected cs.LoadBalancedSet set to be true, got false") assert.Equal(mt, lb, cs.LoadBalanced, "expected cs.LoadBalanced to be %v, got %v", lb, cs.LoadBalanced) case "srvMaxHosts": srvMaxHosts := opt.Int32() assert.Equal(mt, srvMaxHosts, int32(cs.SRVMaxHosts), "expected cs.SRVMaxHosts to be %v, got %v", srvMaxHosts, cs.SRVMaxHosts) case "srvServiceName": srvName := opt.StringValue() assert.Equal(mt, srvName, cs.SRVServiceName, "expected cs.SRVServiceName to be %q, got %q", srvName, cs.SRVServiceName) default: mt.Fatalf("unrecognized connstring option %v", key) } } } // Because the Go driver tests can be run either against a server with SSL enabled or without, a // number of configurations have to be checked to ensure that the SRV tests are run properly. // // First, the "ssl" option in the JSON test description has to be checked. If this option is not // present, we assume that the test will assert an error, so we proceed with the test as normal. // If the option is false, then we skip the test if the server is running with SSL enabled. // If the option is true, then we skip the test if the server is running without SSL enabled; if // the server is running with SSL enabled, then we return a tls.Config with InsecureSkipVerify // set to true. func getSSLSettings(mt mtest.T, test seedlistTest) tls.Config { ssl, err := test.Options.LookupErr("ssl") if err != nil { // No "ssl" option is specified return nil } testCaseExpectsSSL := ssl.Boolean() envSSL := os.Getenv("SSL") == "ssl" // Skip non-SSL tests if the server is running with SSL. if !testCaseExpectsSSL && envSSL { mt.Skip("skipping test that does not expect ssl in an ssl environment") } // Skip SSL tests if the server is running without SSL. if testCaseExpectsSSL && !envSSL { mt.Skip("skipping test that expects ssl in a non-ssl environment") } // If SSL tests are running, set the CA file. if testCaseExpectsSSL && envSSL { tlsConfig := new(tls.Config) tlsConfig.InsecureSkipVerify = true return tlsConfig } return nil } func getServerByAddress(address string, topo topology.Topology) (description.Server, error) { selectByName := description.ServerSelectorFunc(func(_ description.Topology, servers []description.Server) ([]description.Server, error) { for _, s := range servers { if s.Addr.String() == address { return []description.Server{s}, nil } } return []description.Server{}, nil }) selectedServer, err := topo.SelectServer(context.Background(), selectByName) if err != nil { return description.Server{}, err } // If the selected server is a topology.SelectedServer, then we can get the description without creating a // connect pool. topologySelectedServer, ok := selectedServer.(topology.SelectedServer) if ok { return topologySelectedServer.Description().Server, nil } selectedServerConnection, err := selectedServer.Connection(context.Background()) if err != nil { return description.Server{}, err } defer selectedServerConnection.Close() return selectedServerConnection.Description(), nil }	9.56 KB	2025-05-25 12:27
📄 json_helpers_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "crypto/tls" "errors" "fmt" "io/ioutil" "math" "os" "path" "strings" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/mongo/readconcern" "go.mongodb.org/mongo-driver/mongo/readpref" "go.mongodb.org/mongo-driver/mongo/writeconcern" ) var ( awsAccessKeyID = os.Getenv("FLE_AWS_KEY") awsSecretAccessKey = os.Getenv("FLE_AWS_SECRET") awsTempAccessKeyID = os.Getenv("CSFLE_AWS_TEMP_ACCESS_KEY_ID") awsTempSecretAccessKey = os.Getenv("CSFLE_AWS_TEMP_SECRET_ACCESS_KEY") awsTempSessionToken = os.Getenv("CSFLE_AWS_TEMP_SESSION_TOKEN") azureTenantID = os.Getenv("FLE_AZURE_TENANTID") azureClientID = os.Getenv("FLE_AZURE_CLIENTID") azureClientSecret = os.Getenv("FLE_AZURE_CLIENTSECRET") gcpEmail = os.Getenv("FLE_GCP_EMAIL") gcpPrivateKey = os.Getenv("FLE_GCP_PRIVATEKEY") tlsCAFileKMIP = os.Getenv("CSFLE_TLS_CA_FILE") tlsClientCertificateKeyFileKMIP = os.Getenv("CSFLE_TLS_CLIENT_CERT_FILE") ) // Helper functions to do read JSON spec test files and convert JSON objects into the appropriate driver types. // Functions in this file should take testing.TB rather than testing.T/mtest.T for generality because they // do not do any database communication. // generate a slice of all JSON file names in a directory func jsonFilesInDir(t testing.TB, dir string) []string { t.Helper() files := make([]string, 0) entries, err := ioutil.ReadDir(dir) assert.Nil(t, err, "unable to read json file: %v", err) for _, entry := range entries { if entry.IsDir() \|\| path.Ext(entry.Name()) != ".json" { continue } files = append(files, entry.Name()) } return files } // create client options from a map func createClientOptions(t testing.TB, opts bson.Raw) options.ClientOptions { t.Helper() clientOpts := options.Client() elems, _ := opts.Elements() for _, elem := range elems { name := elem.Key() opt := elem.Value() switch name { case "retryWrites": clientOpts.SetRetryWrites(opt.Boolean()) case "w": switch opt.Type { case bson.TypeInt32: w := int(opt.Int32()) clientOpts.SetWriteConcern(writeconcern.New(writeconcern.W(w))) case bson.TypeDouble: w := int(opt.Double()) clientOpts.SetWriteConcern(writeconcern.New(writeconcern.W(w))) case bson.TypeString: clientOpts.SetWriteConcern(writeconcern.New(writeconcern.WMajority())) default: t.Fatalf("unrecognized type for w client option: %v", opt.Type) } case "readConcernLevel": clientOpts.SetReadConcern(readconcern.New(readconcern.Level(opt.StringValue()))) case "readPreference": clientOpts.SetReadPreference(readPrefFromString(opt.StringValue())) case "heartbeatFrequencyMS": hf := convertValueToMilliseconds(t, opt) clientOpts.SetHeartbeatInterval(hf) case "retryReads": clientOpts.SetRetryReads(opt.Boolean()) case "autoEncryptOpts": clientOpts.SetAutoEncryptionOptions(createAutoEncryptionOptions(t, opt.Document())) case "appname": clientOpts.SetAppName(opt.StringValue()) case "connectTimeoutMS": ct := convertValueToMilliseconds(t, opt) clientOpts.SetConnectTimeout(ct) case "serverSelectionTimeoutMS": sst := convertValueToMilliseconds(t, opt) clientOpts.SetServerSelectionTimeout(sst) case "socketTimeoutMS": st := convertValueToMilliseconds(t, opt) clientOpts.SetSocketTimeout(st) case "minPoolSize": clientOpts.SetMinPoolSize(uint64(opt.AsInt64())) case "maxPoolSize": clientOpts.SetMaxPoolSize(uint64(opt.AsInt64())) case "directConnection": clientOpts.SetDirect(opt.Boolean()) default: t.Fatalf("unrecognized client option: %v", name) } } return clientOpts } func createAutoEncryptionOptions(t testing.TB, opts bson.Raw) options.AutoEncryptionOptions { t.Helper() aeo := options.AutoEncryption() var kvnsFound bool elems, _ := opts.Elements() for _, elem := range elems { name := elem.Key() opt := elem.Value() switch name { case "kmsProviders": tlsConfigs := createTLSOptsMap(t, opt.Document()) aeo.SetKmsProviders(createKmsProvidersMap(t, opt.Document())).SetTLSConfig(tlsConfigs) case "schemaMap": var schemaMap map[string]interface{} err := bson.Unmarshal(opt.Document(), &schemaMap) if err != nil { t.Fatalf("error creating schema map: %v", err) } aeo.SetSchemaMap(schemaMap) case "keyVaultNamespace": kvnsFound = true aeo.SetKeyVaultNamespace(opt.StringValue()) case "bypassAutoEncryption": aeo.SetBypassAutoEncryption(opt.Boolean()) case "encryptedFieldsMap": var encryptedFieldsMap map[string]interface{} err := bson.Unmarshal(opt.Document(), &encryptedFieldsMap) if err != nil { t.Fatalf("error creating encryptedFieldsMap: %v", err) } aeo.SetEncryptedFieldsMap(encryptedFieldsMap) case "bypassQueryAnalysis": aeo.SetBypassQueryAnalysis(opt.Boolean()) default: t.Fatalf("unrecognized auto encryption option: %v", name) } } if !kvnsFound { aeo.SetKeyVaultNamespace("keyvault.datakeys") } return aeo } func createTLSOptsMap(t testing.TB, opts bson.Raw) map[string]tls.Config { t.Helper() tlsMap := make(map[string]tls.Config) elems, _ := opts.Elements() for _, elem := range elems { provider := elem.Key() if provider == "kmip" { tlsOptsMap := map[string]interface{}{ "tlsCertificateKeyFile": tlsClientCertificateKeyFileKMIP, "tlsCAFile": tlsCAFileKMIP, } cfg, err := options.BuildTLSConfig(tlsOptsMap) if err != nil { t.Fatalf("error building TLS config map: %v", err) } tlsMap["kmip"] = cfg } } return tlsMap } func createKmsProvidersMap(t testing.TB, opts bson.Raw) map[string]map[string]interface{} { t.Helper() kmsMap := make(map[string]map[string]interface{}) elems, _ := opts.Elements() for _, elem := range elems { provider := elem.Key() providerOpt := elem.Value() switch provider { case "aws": awsMap := map[string]interface{}{ "accessKeyId": awsAccessKeyID, "secretAccessKey": awsSecretAccessKey, } kmsMap["aws"] = awsMap case "azure": kmsMap["azure"] = map[string]interface{}{ "tenantId": azureTenantID, "clientId": azureClientID, "clientSecret": azureClientSecret, } case "gcp": kmsMap["gcp"] = map[string]interface{}{ "email": gcpEmail, "privateKey": gcpPrivateKey, } case "local": _, key := providerOpt.Document().Lookup("key").Binary() localMap := map[string]interface{}{ "key": key, } kmsMap["local"] = localMap case "awsTemporary": if awsTempAccessKeyID == "" { t.Fatal("AWS temp access key ID not set") } if awsTempSecretAccessKey == "" { t.Fatal("AWS temp secret access key not set") } if awsTempSessionToken == "" { t.Fatal("AWS temp session token not set") } awsMap := map[string]interface{}{ "accessKeyId": awsTempAccessKeyID, "secretAccessKey": awsTempSecretAccessKey, "sessionToken": awsTempSessionToken, } kmsMap["aws"] = awsMap case "awsTemporaryNoSessionToken": if awsTempAccessKeyID == "" { t.Fatal("AWS temp access key ID not set") } if awsTempSecretAccessKey == "" { t.Fatal("AWS temp secret access key not set") } awsMap := map[string]interface{}{ "accessKeyId": awsTempAccessKeyID, "secretAccessKey": awsTempSecretAccessKey, } kmsMap["aws"] = awsMap case "kmip": kmipMap := map[string]interface{}{ "endpoint": "localhost:5698", } kmsMap["kmip"] = kmipMap default: t.Fatalf("unrecognized KMS provider: %v", provider) } } return kmsMap } // create session options from a map func createSessionOptions(t testing.TB, opts bson.Raw) options.SessionOptions { t.Helper() sessOpts := options.Session() elems, _ := opts.Elements() for _, elem := range elems { name := elem.Key() opt := elem.Value() switch name { case "causalConsistency": sessOpts = sessOpts.SetCausalConsistency(opt.Boolean()) case "defaultTransactionOptions": txnOpts := createTransactionOptions(t, opt.Document()) if txnOpts.ReadConcern != nil { sessOpts.SetDefaultReadConcern(txnOpts.ReadConcern) } if txnOpts.ReadPreference != nil { sessOpts.SetDefaultReadPreference(txnOpts.ReadPreference) } if txnOpts.WriteConcern != nil { sessOpts.SetDefaultWriteConcern(txnOpts.WriteConcern) } if txnOpts.MaxCommitTime != nil { sessOpts.SetDefaultMaxCommitTime(txnOpts.MaxCommitTime) } default: t.Fatalf("unrecognized session option: %v", name) } } return sessOpts } // create database options from a BSON document. func createDatabaseOptions(t testing.TB, opts bson.Raw) options.DatabaseOptions { t.Helper() do := options.Database() elems, _ := opts.Elements() for _, elem := range elems { name := elem.Key() opt := elem.Value() switch name { case "readConcern": do.SetReadConcern(createReadConcern(opt)) case "writeConcern": do.SetWriteConcern(createWriteConcern(t, opt)) default: t.Fatalf("unrecognized database option: %v", name) } } return do } // create collection options from a map func createCollectionOptions(t testing.TB, opts bson.Raw) options.CollectionOptions { t.Helper() co := options.Collection() elems, _ := opts.Elements() for _, elem := range elems { name := elem.Key() opt := elem.Value() switch name { case "readConcern": co.SetReadConcern(createReadConcern(opt)) case "writeConcern": co.SetWriteConcern(createWriteConcern(t, opt)) case "readPreference": co.SetReadPreference(createReadPref(opt)) default: t.Fatalf("unrecognized collection option: %v", name) } } return co } // create transaction options from a map func createTransactionOptions(t testing.TB, opts bson.Raw) options.TransactionOptions { t.Helper() txnOpts := options.Transaction() elems, _ := opts.Elements() for _, elem := range elems { name := elem.Key() opt := elem.Value() switch name { case "writeConcern": txnOpts.SetWriteConcern(createWriteConcern(t, opt)) case "readPreference": txnOpts.SetReadPreference(createReadPref(opt)) case "readConcern": txnOpts.SetReadConcern(createReadConcern(opt)) case "maxCommitTimeMS": t := time.Duration(opt.Int32()) * time.Millisecond txnOpts.SetMaxCommitTime(&t) default: t.Fatalf("unrecognized transaction option: %v", opt) } } return txnOpts } // create a read concern from a map func createReadConcern(opt bson.RawValue) readconcern.ReadConcern { return readconcern.New(readconcern.Level(opt.Document().Lookup("level").StringValue())) } // create a read concern from a map func createWriteConcern(t testing.TB, opt bson.RawValue) writeconcern.WriteConcern { wcDoc, ok := opt.DocumentOK() if !ok { return nil } var opts []writeconcern.Option elems, _ := wcDoc.Elements() for _, elem := range elems { key := elem.Key() val := elem.Value() switch key { case "wtimeout": wtimeout := convertValueToMilliseconds(t, val) opts = append(opts, writeconcern.WTimeout(wtimeout)) case "j": opts = append(opts, writeconcern.J(val.Boolean())) case "w": switch val.Type { case bson.TypeString: if val.StringValue() != "majority" { break } opts = append(opts, writeconcern.WMajority()) case bson.TypeInt32: w := int(val.Int32()) opts = append(opts, writeconcern.W(w)) default: t.Fatalf("unrecognized type for w: %v", val.Type) } default: t.Fatalf("unrecognized write concern option: %v", key) } } return writeconcern.New(opts...) } // create a read preference from a string. // returns readpref.Primary() if the string doesn't match any known read preference modes. func readPrefFromString(s string) readpref.ReadPref { switch strings.ToLower(s) { case "primary": return readpref.Primary() case "primarypreferred": return readpref.PrimaryPreferred() case "secondary": return readpref.Secondary() case "secondarypreferred": return readpref.SecondaryPreferred() case "nearest": return readpref.Nearest() } return readpref.Primary() } // create a read preference from a map. func createReadPref(opt bson.RawValue) readpref.ReadPref { mode := opt.Document().Lookup("mode").StringValue() return readPrefFromString(mode) } // retrieve the error associated with a result. func errorFromResult(t testing.TB, result interface{}) operationError { t.Helper() // embedded doc will be unmarshalled as Raw raw, ok := result.(bson.Raw) if !ok { return nil } var expected operationError err := bson.Unmarshal(raw, &expected) if err != nil { return nil } if expected.ErrorCodeName == nil && expected.ErrorContains == nil && len(expected.ErrorLabelsOmit) == 0 && len(expected.ErrorLabelsContain) == 0 { return nil } return &expected } // errorDetails is a helper type that holds information that can be returned by driver functions in different error // types. type errorDetails struct { name string labels []string } // extractErrorDetails creates an errorDetails instance based on the provided error. It returns the details and an "ok" // value which is true if the provided error is of a known type that can be processed. func extractErrorDetails(err error) (errorDetails, bool) { var details errorDetails switch converted := err.(type) { case mongo.CommandError: details.name = converted.Name details.labels = converted.Labels case mongo.WriteException: if converted.WriteConcernError != nil { details.name = converted.WriteConcernError.Name } details.labels = converted.Labels case mongo.BulkWriteException: if converted.WriteConcernError != nil { details.name = converted.WriteConcernError.Name } details.labels = converted.Labels default: return errorDetails{}, false } return details, true } // verify that an error returned by an operation matches the expected error. func verifyError(expected operationError, actual error) error { // The spec test format doesn't treat ErrNoDocuments or ErrUnacknowledgedWrite as errors, so set actual to nil // to indicate that no error occurred. if errors.Is(actual, mongo.ErrNoDocuments) \|\| errors.Is(actual, mongo.ErrUnacknowledgedWrite) { actual = nil } if expected == nil && actual != nil { return fmt.Errorf("did not expect error but got %w", actual) } if expected != nil && actual == nil { return fmt.Errorf("expected error but got nil") } if expected == nil { return nil } // check ErrorContains for all error types if expected.ErrorContains != nil { emsg := strings.ToLower(expected.ErrorContains) amsg := strings.ToLower(actual.Error()) if !strings.Contains(amsg, emsg) { return fmt.Errorf("expected error message %q to contain %q", amsg, emsg) } } // Get an errorDetails instance for the error. If this fails but the test has expectations about the error name or // labels, fail because we can't verify them. details, ok := extractErrorDetails(actual) if !ok { if expected.ErrorCodeName != nil \|\| len(expected.ErrorLabelsContain) > 0 \|\| len(expected.ErrorLabelsOmit) > 0 { return fmt.Errorf("failed to extract details from error %v of type %T", actual, actual) } return nil } if expected.ErrorCodeName != nil { if expected.ErrorCodeName != details.name { return fmt.Errorf("expected error name %v, got %v", expected.ErrorCodeName, details.name) } } for _, label := range expected.ErrorLabelsContain { if !stringSliceContains(details.labels, label) { return fmt.Errorf("expected error %w to contain label %q", actual, label) } } for _, label := range expected.ErrorLabelsOmit { if stringSliceContains(details.labels, label) { return fmt.Errorf("expected error %w to not contain label %q", actual, label) } } return nil } // get the underlying value of i as an int64. returns nil if i is not an int, int32, or int64 type. func getIntFromInterface(i interface{}) int64 { var out int64 switch v := i.(type) { case int: out = int64(v) case int32: out = int64(v) case int64: out = v case float32: f := float64(v) if math.Floor(f) != f \|\| f > float64(math.MaxInt64) { break } out = int64(f) case float64: if math.Floor(v) != v \|\| v > float64(math.MaxInt64) { break } out = int64(v) default: return nil } return &out } func createCollation(t testing.TB, m bson.Raw) options.Collation { var collation options.Collation elems, _ := m.Elements() for _, elem := range elems { switch elem.Key() { case "locale": collation.Locale = elem.Value().StringValue() case "caseLevel": collation.CaseLevel = elem.Value().Boolean() case "caseFirst": collation.CaseFirst = elem.Value().StringValue() case "strength": collation.Strength = int(elem.Value().Int32()) case "numericOrdering": collation.NumericOrdering = elem.Value().Boolean() case "alternate": collation.Alternate = elem.Value().StringValue() case "maxVariable": collation.MaxVariable = elem.Value().StringValue() case "normalization": collation.Normalization = elem.Value().Boolean() case "backwards": collation.Backwards = elem.Value().Boolean() default: t.Fatalf("unrecognized collation option: %v", elem.Key()) } } return &collation } func convertValueToMilliseconds(t testing.TB, val bson.RawValue) time.Duration { t.Helper() int32Val, ok := val.Int32OK() if !ok { t.Fatalf("failed to convert value of type %s to int32", val.Type) } return time.Duration(int32Val) time.Millisecond } func stringSliceContains(stringSlice []string, target string) bool { for _, str := range stringSlice { if str == target { return true } } return false }	17.75 KB	2025-05-25 12:27
📄 load_balancer_prose_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "fmt" "strings" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/require" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" ) func TestLoadBalancerSupport(t testing.T) { mt := mtest.New(t, mtest.NewOptions().Topologies(mtest.LoadBalanced).CreateClient(false)) mt.Run("RunCommandCursor pins to a connection", func(mt mtest.T) { // The LB spec tests cover the behavior for cursors created by CRUD operations, but RunCommandCursor is // Go-specific so there is no spec test coverage for it. initCollection(mt, mt.Coll) findCmd := bson.D{ {"find", mt.Coll.Name()}, {"filter", bson.D{}}, {"batchSize", 2}, } cursor, err := mt.DB.RunCommandCursor(context.Background(), findCmd) assert.Nil(mt, err, "RunCommandCursor error: %v", err) defer func() { _ = cursor.Close(context.Background()) }() assert.True(mt, cursor.ID() > 0, "expected cursor ID to be non-zero") assert.Equal(mt, 1, mt.NumberConnectionsCheckedOut(), "expected one connection to be checked out, got %d", mt.NumberConnectionsCheckedOut()) }) mt.RunOpts("wait queue timeout errors include extra information", noClientOpts, func(mt mtest.T) { // There are spec tests to assert this behavior, but they rely on the waitQueueTimeoutMS Client option, which is // not supported in Go, so we have to skip them. These prose tests make the same assertions, but use context // deadlines to force wait queue timeout errors. assertErrorHasInfo := func(mt mtest.T, err error, numCursorConns, numTxnConns, numOtherConns int) { mt.Helper() assert.NotNil(mt, err, "expected wait queue timeout error, got nil") expectedMsg := fmt.Sprintf("maxPoolSize: 1, "+ "connections in use by cursors: %d, "+ "connections in use by transactions: %d, "+ "connections in use by other operations: %d", numCursorConns, numTxnConns, numOtherConns, ) assert.True(mt, strings.Contains(err.Error(), expectedMsg), "expected error %q to contain substring %q", err, expectedMsg) } maxPoolSizeMtOpts := mtest.NewOptions(). ClientOptions(options.Client().SetMaxPoolSize(1)) mt.RunOpts("cursors", maxPoolSizeMtOpts, func(mt mtest.T) { initCollection(mt, mt.Coll) findOpts := options.Find().SetBatchSize(2) cursor, err := mt.Coll.Find(context.Background(), bson.M{}, findOpts) assert.Nil(mt, err, "Find error: %v", err) defer func() { _ = cursor.Close(context.Background()) }() ctx, cancel := context.WithTimeout(context.Background(), 5time.Millisecond) defer cancel() _, err = mt.Coll.InsertOne(ctx, bson.M{"x": 1}) assertErrorHasInfo(mt, err, 1, 0, 0) }) mt.RunOpts("transactions", maxPoolSizeMtOpts, func(mt mtest.T) { { sess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) defer sess.EndSession(context.Background()) ctx := mongo.NewSessionContext(context.Background(), sess) // Start a transaction and perform one transactional operation to pin a connection. err = sess.StartTransaction() assert.Nil(mt, err, "StartTransaction error: %v", err) _, err = mt.Coll.InsertOne(ctx, bson.M{"x": 1}) assert.Nil(mt, err, "InsertOne error: %v", err) } ctx, cancel := context.WithTimeout(context.Background(), 5time.Millisecond) defer cancel() _, err := mt.Coll.InsertOne(ctx, bson.M{"x": 1}) assertErrorHasInfo(mt, err, 0, 1, 0) }) // GODRIVER-2867: Test that connections are unpinned from transactions // when the transaction session is ended. Create a Client with // maxPoolSize=1 and expect that it can start and commit 5 transactions // with that 1 connection. mt.RunOpts("transaction connections are unpinned", maxPoolSizeMtOpts, func(mt mtest.T) { { ctx, cancel := context.WithTimeout(context.Background(), 1time.Minute) defer cancel() for i := 0; i < 5; i++ { sess, err := mt.Client.StartSession() require.NoError(mt, err, "StartSession error") err = sess.StartTransaction() require.NoError(mt, err, "StartTransaction error") ctx := mongo.NewSessionContext(ctx, sess) _, err = mt.Coll.InsertOne(ctx, bson.M{"x": 1}) assert.NoError(mt, err, "InsertOne error") err = sess.CommitTransaction(ctx) assert.NoError(mt, err, "CommitTransaction error") sess.EndSession(ctx) } } }) }) }	4.71 KB	2025-05-25 12:27
📄 log_helpers_test.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "fmt" "go.mongodb.org/mongo-driver/internal/logger" "go.mongodb.org/mongo-driver/mongo/integration/mtest" ) type testLogSink struct { logs chan func() (int, string, []interface{}) bufferSize int logsCount int errsCh chan error } type logValidator func(order int, lvl int, msg string, kv ...interface{}) error func newTestLogSink(ctx context.Context, mt mtest.T, bufferSize int, validator logValidator) testLogSink { mt.Helper() sink := &testLogSink{ logs: make(chan func() (int, string, []interface{}), bufferSize), errsCh: make(chan error, bufferSize), bufferSize: bufferSize, } go func() { order := 0 for log := range sink.logs { select { case <-ctx.Done(): sink.errsCh <- ctx.Err() return default: } level, msg, args := log() if err := validator(order, level, msg, args...); err != nil { sink.errsCh <- fmt.Errorf("invalid log at position %d, level %d, and msg %q: %w", order, level, msg, err) } order++ } close(sink.errsCh) }() return sink } func (sink testLogSink) Info(level int, msg string, keysAndValues ...interface{}) { sink.logs <- func() (int, string, []interface{}) { return level, msg, keysAndValues } if sink.logsCount++; sink.logsCount == sink.bufferSize { close(sink.logs) } } func (sink testLogSink) Error(err error, msg string, keysAndValues ...interface{}) { keysAndValues = append(keysAndValues, "error", err) sink.Info(int(logger.LevelInfo), msg, keysAndValues) } func (sink testLogSink) errs() <-chan error { return sink.errsCh } func findLogValue(mt mtest.T, key string, values ...interface{}) interface{} { mt.Helper() for i := 0; i < len(values); i += 2 { if values[i] == key { return values[i+1] } } return nil } type truncValidator func(values ...interface{}) error // newTruncValidator will return a logger validator for validating truncated // messages. It takes the key for the portion of the document to validate // (e.g. "command" for started events, "reply" for finished events, etc), and // returns an anonymous function that can be used to validate the truncated // message. func newTruncValidator(mt *mtest.T, key string, cond func(string) error) truncValidator { mt.Helper() return func(values ...interface{}) error { cmd := findLogValue(mt, key, values...) if cmd == nil { return fmt.Errorf("%q not found in keys and values", key) } cmdStr, ok := cmd.(string) if !ok { return fmt.Errorf("command is not a string") } return cond(cmdStr) } }	2.79 KB	2025-05-25 12:27
📄 main.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration // This file exists to allow the build scripts (and standard Go builds for some early Go versions) // to succeed. Without it, the build may encounter an error like: // // go build go.mongodb.org/mongo-driver/mongo/integration: build constraints exclude all Go files in ./go.mongodb.org/mongo-driver/mongo/integration //	613 B	2025-05-25 12:27
📄 main_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "flag" "log" "os" "testing" "go.mongodb.org/mongo-driver/mongo/integration/mtest" ) func TestMain(m *testing.M) { // All tests that use mtest.Setup() are expected to be integration tests, so skip them when the // -short flag is included in the "go test" command. Also, we have to parse flags here to use // testing.Short() because flags aren't parsed before TestMain() is called. flag.Parse() if testing.Short() { log.Print("skipping mtest integration test in short mode") return } if err := mtest.Setup(); err != nil { log.Fatal(err) } defer os.Exit(m.Run()) if err := mtest.Teardown(); err != nil { log.Fatal(err) } }	947 B	2025-05-25 12:27
📄 mock_find_test.go // Copyright (C) MongoDB, Inc. 2021-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "testing" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" ) // finder is an object that implements FindOne and Find. type finder interface { FindOne(ctx context.Context, filter interface{}, opts ...options.FindOneOptions) mongo.SingleResult Find(context.Context, interface{}, ...options.FindOptions) (mongo.Cursor, error) } // mockFinder implements finder. type mockFinder struct { docs []interface{} err error registry bsoncodec.Registry } // FindOne mocks a findOne operation using NewSingleResultFromDocument. func (mf mockFinder) FindOne(_ context.Context, _ interface{}, _ ...options.FindOneOptions) mongo.SingleResult { return mongo.NewSingleResultFromDocument(mf.docs[0], mf.err, mf.registry) } // Find mocks a find operation using NewCursorFromDocuments. func (mf mockFinder) Find(context.Context, interface{}, ...options.FindOptions) (mongo.Cursor, error) { return mongo.NewCursorFromDocuments(mf.docs, mf.err, mf.registry) } // ShopItem is an item with an associated ID and price. type ShopItem struct { ID int `bson:"id"` Price float64 `bson:"price"` } // getItem is an example function using the interface finder to test the mocking of SingleResult. func getItem(f finder, id int) (ShopItem, error) { res := f.FindOne(context.Background(), bson.D{{"id", id}}) var item ShopItem err := res.Decode(&item) return &item, err } // getItems is an example function using the interface finder to test the mocking of Cursor. func getItems(f finder) ([]ShopItem, error) { cur, err := f.Find(context.Background(), bson.D{}) if err != nil { return nil, err } var items []ShopItem err = cur.All(context.Background(), &items) return items, err } func TestMockFind(t testing.T) { mt := mtest.New(t, mtest.NewOptions().CreateClient(false)) insertItems := []interface{}{ ShopItem{ID: 0, Price: 1.5}, ShopItem{ID: 1, Price: 5.7}, ShopItem{ID: 2, Price: 0.25}, } insertItem := []interface{}{ShopItem{ID: 1, Price: 5.7}} mt.Run("mongo.Collection can be passed as interface", func(mt mtest.T) { // Actually insert documents to collection. _, err := mt.Coll.InsertMany(context.Background(), insertItems) assert.Nil(mt, err, "InsertMany error: %v", err) // Assert that FindOne behaves as expected. shopItem, err := getItem(mt.Coll, 1) assert.Nil(mt, err, "getItem error: %v", err) assert.Equal(mt, 1, shopItem.ID) assert.Equal(mt, 5.7, shopItem.Price) // Assert that Find behaves as expected. shopItems, err := getItems(mt.Coll) assert.Nil(mt, err, "getItems error: %v", err) for i, shopItem := range shopItems { expectedItem := insertItems[i].(ShopItem) assert.Equal(mt, expectedItem.ID, shopItem.ID) assert.Equal(mt, expectedItem.Price, shopItem.Price) } }) mt.Run("FindOne can be mocked", func(mt mtest.T) { // Mock a FindOne result with mockFinder. mf := &mockFinder{docs: insertItem, err: nil, registry: nil} // Assert that FindOne behaves as expected. shopItem, err := getItem(mf, 1) assert.Nil(mt, err, "getItem error: %v", err) assert.Equal(mt, 1, shopItem.ID) assert.Equal(mt, 5.7, shopItem.Price) }) mt.Run("Find can be mocked", func(mt mtest.T) { // Mock a Find result with mockFinder. mf := &mockFinder{docs: insertItems, err: nil, registry: nil} // Assert that Find behaves as expected. shopItems, err := getItems(mf) assert.Nil(mt, err, "getItems error: %v", err) for i, shopItem := range shopItems { expectedItem := insertItems[i].(ShopItem) assert.Equal(mt, expectedItem.ID, shopItem.ID) assert.Equal(mt, expectedItem.Price, shopItem.Price) } }) }	4.04 KB	2025-05-25 12:27
📄 mongos_pinning_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "fmt" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" ) func TestMongosPinning(t testing.T) { clientOpts := options.Client().SetLocalThreshold(1 time.Second).SetWriteConcern(mtest.MajorityWc) mtOpts := mtest.NewOptions().Topologies(mtest.Sharded).MinServerVersion("4.1").CreateClient(false). ClientOptions(clientOpts) mt := mtest.New(t, mtOpts) if len(options.Client().ApplyURI(mtest.ClusterURI()).Hosts) < 2 { mt.Skip("skipping because at least 2 mongoses are required") } mt.Run("unpin for next transaction", func(mt mtest.T) { addresses := map[string]struct{}{} _ = mt.Client.UseSession(context.Background(), func(sc mongo.SessionContext) error { // Insert a document in a transaction to pin session to a mongos err := sc.StartTransaction() assert.Nil(mt, err, "StartTransaction error: %v", err) _, err = mt.Coll.InsertOne(sc, bson.D{{"x", 1}}) assert.Nil(mt, err, "InsertOne error: %v", err) err = sc.CommitTransaction(sc) assert.Nil(mt, err, "CommitTransaction error: %v", err) for i := 0; i < 50; i++ { // Call Find in a new transaction to unpin from the old mongos and select a new one err = sc.StartTransaction() assert.Nil(mt, err, iterationErrmsg("StartTransaction", i, err)) cursor, err := mt.Coll.Find(sc, bson.D{}) assert.Nil(mt, err, iterationErrmsg("Find", i, err)) assert.True(mt, cursor.Next(context.Background()), "Next returned false on iteration %v", i) descConn, err := mongo.BatchCursorFromCursor(cursor).Server().Connection(context.Background()) assert.Nil(mt, err, iterationErrmsg("Connection", i, err)) addresses[descConn.Description().Addr.String()] = struct{}{} err = descConn.Close() assert.Nil(mt, err, iterationErrmsg("connection Close", i, err)) err = sc.CommitTransaction(sc) assert.Nil(mt, err, iterationErrmsg("CommitTransaction", i, err)) } return nil }) assert.True(mt, len(addresses) > 1, "expected more than 1 address, got %v", addresses) }) mt.Run("unpin for non transaction operation", func(mt mtest.T) { addresses := map[string]struct{}{} _ = mt.Client.UseSession(context.Background(), func(sc mongo.SessionContext) error { // Insert a document in a transaction to pin session to a mongos err := sc.StartTransaction() assert.Nil(mt, err, "StartTransaction error: %v", err) _, err = mt.Coll.InsertOne(sc, bson.D{{"x", 1}}) assert.Nil(mt, err, "InsertOne error: %v", err) err = sc.CommitTransaction(sc) assert.Nil(mt, err, "CommitTransaction error: %v", err) for i := 0; i < 50; i++ { // Call Find with the session but outside of a transaction cursor, err := mt.Coll.Find(sc, bson.D{}) assert.Nil(mt, err, iterationErrmsg("Find", i, err)) assert.True(mt, cursor.Next(context.Background()), "Next returned false on iteration %v", i) descConn, err := mongo.BatchCursorFromCursor(cursor).Server().Connection(context.Background()) assert.Nil(mt, err, iterationErrmsg("Connection", i, err)) addresses[descConn.Description().Addr.String()] = struct{}{} err = descConn.Close() assert.Nil(mt, err, iterationErrmsg("connection Close", i, err)) } return nil }) assert.True(mt, len(addresses) > 1, "expected more than 1 address, got %v", addresses) }) } func iterationErrmsg(op string, i int, wrapped error) string { return fmt.Sprintf("%v error on iteration %v: %v", op, i, wrapped) }	3.82 KB	2025-05-25 12:27
📁 mtest	-	2025-05-25 12:27
📄 primary_stepdown_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "testing" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/eventtest" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" ) const ( errorNotPrimary int32 = 10107 errorShutdownInProgress int32 = 91 errorInterruptedAtShutdown int32 = 11600 ) func TestConnectionsSurvivePrimaryStepDown(t testing.T) { mt := mtest.New(t, mtest.NewOptions().Topologies(mtest.ReplicaSet).CreateClient(false)) getMoreOpts := mtest.NewOptions().MinServerVersion("4.2") mt.RunOpts("getMore iteration", getMoreOpts, func(mt mtest.T) { tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(options.Client(). SetRetryWrites(false). SetPoolMonitor(tpm.PoolMonitor)) initCollection(mt, mt.Coll) cur, err := mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetBatchSize(2)) assert.Nil(mt, err, "Find error: %v", err) defer cur.Close(context.Background()) assert.True(mt, cur.Next(context.Background()), "expected Next true, got false") // replSetStepDown can fail with transient errors, so we use executeAdminCommandWithRetry to handle them and // retry until a timeout is hit. stepDownCmd := bson.D{ {"replSetStepDown", 5}, {"force", true}, } stepDownOpts := options.RunCmd().SetReadPreference(mtest.PrimaryRp) executeAdminCommandWithRetry(mt, mt.Client, stepDownCmd, stepDownOpts) assert.True(mt, cur.Next(context.Background()), "expected Next true, got false") assert.False(mt, tpm.IsPoolCleared(), "expected pool to not be cleared but was") }) mt.RunOpts("server errors", noClientOpts, func(mt mtest.T) { testCases := []struct { name string minVersion, maxVersion string errCode int32 poolCleared bool }{ {"notPrimary keep pool", "4.2", "", errorNotPrimary, false}, {"notPrimary reset pool", "4.0", "4.0", errorNotPrimary, true}, {"shutdown in progress reset pool", "4.0", "", errorShutdownInProgress, true}, {"interrupted at shutdown reset pool", "4.0", "", errorInterruptedAtShutdown, true}, } for _, tc := range testCases { opts := mtest.NewOptions() if tc.minVersion != "" { opts.MinServerVersion(tc.minVersion) } if tc.maxVersion != "" { opts.MaxServerVersion(tc.maxVersion) } mt.RunOpts(tc.name, opts, func(mt mtest.T) { tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(options.Client(). SetRetryWrites(false). SetPoolMonitor(tpm.PoolMonitor). // Use a low heartbeat frequency so the Client will quickly recover when using // failpoints that cause SDAM state changes. SetHeartbeatInterval(defaultHeartbeatInterval)) mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"insert"}, ErrorCode: tc.errCode, }, }) _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"test", 1}}) assert.NotNil(mt, err, "expected InsertOne error, got nil") cerr, ok := err.(mongo.CommandError) assert.True(mt, ok, "expected error type %v, got %v", mongo.CommandError{}, err) assert.Equal(mt, tc.errCode, cerr.Code, "expected error code %v, got %v", tc.errCode, cerr.Code) if tc.poolCleared { assert.True(mt, tpm.IsPoolCleared(), "expected pool to be cleared but was not") return } // if pool shouldn't be cleared, another operation should succeed _, err = mt.Coll.InsertOne(context.Background(), bson.D{{"test", 1}}) assert.Nil(mt, err, "InsertOne error: %v", err) assert.False(mt, tpm.IsPoolCleared(), "expected pool to not be cleared but was") }) } }) }	4.04 KB	2025-05-25 12:27
📄 retryable_reads_prose_test.go // Copyright (C) MongoDB, Inc. 2022-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "sync" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/eventtest" "go.mongodb.org/mongo-driver/internal/require" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" ) func TestRetryableReadsProse(t testing.T) { tpm := eventtest.NewTestPoolMonitor() // Client options with MaxPoolSize of 1 and RetryReads used per the test description. // Lower HeartbeatInterval used to speed the test up for any server that uses streaming // heartbeats. Only connect to first host in list for sharded clusters. hosts := mtest.ClusterConnString().Hosts clientOpts := options.Client().SetMaxPoolSize(1).SetRetryReads(true). SetPoolMonitor(tpm.PoolMonitor).SetHeartbeatInterval(500 time.Millisecond). SetHosts(hosts[:1]) mtOpts := mtest.NewOptions().ClientOptions(clientOpts).MinServerVersion("4.3") mt := mtest.New(t, mtOpts) mt.Run("PoolClearedError retryability", func(mt mtest.T) { if mtest.ClusterTopologyKind() == mtest.LoadBalanced { mt.Skip("skipping as load balanced topology has different pool clearing behavior") } // Insert a document to test collection. _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"x", 1}}) assert.Nil(mt, err, "InsertOne error: %v", err) // Force Find to block for 1 second once. mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"find"}, ErrorCode: 91, BlockConnection: true, BlockTimeMS: 1000, }, }) // Clear CMAP and command events. tpm.ClearEvents() mt.ClearEvents() // Perform a FindOne on two different threads and assert both operations are // successful. var wg sync.WaitGroup for i := 0; i < 2; i++ { wg.Add(1) go func() { defer wg.Done() res := mt.Coll.FindOne(context.Background(), bson.D{}) assert.Nil(mt, res.Err()) }() } wg.Wait() // Gather GetSucceeded, GetFailed and PoolCleared pool events. events := tpm.Events(func(e event.PoolEvent) bool { getSucceeded := e.Type == event.GetSucceeded getFailed := e.Type == event.GetFailed poolCleared := e.Type == event.PoolCleared return getSucceeded \|\| getFailed \|\| poolCleared }) // Assert that first check out succeeds, pool is cleared, and second check // out fails due to connection error. assert.True(mt, len(events) >= 3, "expected at least 3 events, got %v", len(events)) assert.Equal(mt, event.GetSucceeded, events[0].Type, "expected ConnectionCheckedOut event, got %v", events[0].Type) assert.Equal(mt, event.PoolCleared, events[1].Type, "expected ConnectionPoolCleared event, got %v", events[1].Type) assert.Equal(mt, event.GetFailed, events[2].Type, "expected ConnectionCheckedOutFailed event, got %v", events[2].Type) assert.Equal(mt, event.ReasonConnectionErrored, events[2].Reason, "expected check out failure due to connection error, failed due to %q", events[2].Reason) // Assert that three find CommandStartedEvents were observed. for i := 0; i < 3; i++ { cmdEvt := mt.GetStartedEvent() assert.NotNil(mt, cmdEvt, "expected a find event, got nil") assert.Equal(mt, cmdEvt.CommandName, "find", "expected a find event, got a(n) %v event", cmdEvt.CommandName) } }) mtOpts = mtest.NewOptions().Topologies(mtest.Sharded).MinServerVersion("4.2") mt.RunOpts("retrying in sharded cluster", mtOpts, func(mt mtest.T) { tests := []struct { name string // Note that setting this value greater than 2 will result in false // negatives. The current specification does not account for CSOT, which // might allow for an "infinite" number of retries over a period of time. // Because of this, we only track the "previous server". hostCount int failpointErrorCode int32 expectedFailCount int expectedSuccessCount int }{ { name: "retry on different mongos", hostCount: 2, failpointErrorCode: 6, // HostUnreachable expectedFailCount: 2, expectedSuccessCount: 0, }, { name: "retry on same mongos", hostCount: 1, failpointErrorCode: 6, // HostUnreachable expectedFailCount: 1, expectedSuccessCount: 1, }, } for _, tc := range tests { mt.Run(tc.name, func(mt mtest.T) { hosts := options.Client().ApplyURI(mtest.ClusterURI()).Hosts require.GreaterOrEqualf(mt, len(hosts), tc.hostCount, "test cluster must have at least %v mongos hosts", tc.hostCount) // Configure the failpoint options for each mongos. failPoint := mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"find"}, ErrorCode: tc.failpointErrorCode, CloseConnection: false, }, } // In order to ensure that each mongos in the hostCount-many mongos // hosts are tried at least once (i.e. failures are deprioritized), we // set a failpoint on all mongos hosts. The idea is that if we get // hostCount-many failures, then by the pigeonhole principal all mongos // hosts must have been tried. for i := 0; i < tc.hostCount; i++ { mt.ResetClient(options.Client().SetHosts([]string{hosts[i]})) mt.SetFailPoint(failPoint) // The automatic failpoint clearing may not clear failpoints set on // specific hosts, so manually clear the failpoint we set on the // specific mongos when the test is done. defer mt.ResetClient(options.Client().SetHosts([]string{hosts[i]})) defer mt.ClearFailPoints() } failCount := 0 successCount := 0 commandMonitor := &event.CommandMonitor{ Failed: func(context.Context, event.CommandFailedEvent) { failCount++ }, Succeeded: func(context.Context, event.CommandSucceededEvent) { successCount++ }, } // Reset the client with exactly hostCount-many mongos hosts. mt.ResetClient(options.Client(). SetHosts(hosts[:tc.hostCount]). SetRetryReads(true). SetMonitor(commandMonitor)) mt.Coll.FindOne(context.Background(), bson.D{}) assert.Equal(mt, tc.expectedFailCount, failCount) assert.Equal(mt, tc.expectedSuccessCount, successCount) }) } }) }	6.64 KB	2025-05-25 12:27
📄 retryable_writes_prose_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "bytes" "context" "fmt" "sync" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/eventtest" "go.mongodb.org/mongo-driver/internal/require" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/x/mongo/driver" ) func TestRetryableWritesProse(t testing.T) { clientOpts := options.Client().SetRetryWrites(true).SetWriteConcern(mtest.MajorityWc). SetReadConcern(mtest.MajorityRc) mtOpts := mtest.NewOptions().ClientOptions(clientOpts).MinServerVersion("3.6").CreateClient(false) mt := mtest.New(t, mtOpts) includeOpts := mtest.NewOptions().Topologies(mtest.ReplicaSet, mtest.Sharded).CreateClient(false) mt.RunOpts("txn number included", includeOpts, func(mt mtest.T) { updateDoc := bson.D{{"$inc", bson.D{{"x", 1}}}} insertOneDoc := bson.D{{"x", 1}} insertManyOrderedArgs := bson.D{ {"options", bson.D{{"ordered", true}}}, {"documents", []interface{}{insertOneDoc}}, } insertManyUnorderedArgs := bson.D{ {"options", bson.D{{"ordered", true}}}, {"documents", []interface{}{insertOneDoc}}, } testCases := []struct { operationName string args bson.D expectTxnNumber bool }{ {"deleteOne", bson.D{}, true}, {"deleteMany", bson.D{}, false}, {"updateOne", bson.D{{"update", updateDoc}}, true}, {"updateMany", bson.D{{"update", updateDoc}}, false}, {"replaceOne", bson.D{}, true}, {"insertOne", bson.D{{"document", insertOneDoc}}, true}, {"insertMany", insertManyOrderedArgs, true}, {"insertMany", insertManyUnorderedArgs, true}, {"findOneAndReplace", bson.D{}, true}, {"findOneAndUpdate", bson.D{{"update", updateDoc}}, true}, {"findOneAndDelete", bson.D{}, true}, } for _, tc := range testCases { mt.Run(tc.operationName, func(mt mtest.T) { tcArgs, err := bson.Marshal(tc.args) assert.Nil(mt, err, "Marshal error: %v", err) crudOp := crudOperation{ Name: tc.operationName, Arguments: tcArgs, } mt.ClearEvents() runCrudOperation(mt, "", crudOp, crudOutcome{}) started := mt.GetStartedEvent() assert.NotNil(mt, started, "expected CommandStartedEvent, got nil") _, err = started.Command.LookupErr("txnNumber") if tc.expectTxnNumber { assert.Nil(mt, err, "expected txnNumber in command %v", started.Command) return } assert.NotNil(mt, err, "did not expect txnNumber in command %v", started.Command) }) } }) errorOpts := mtest.NewOptions().Topologies(mtest.ReplicaSet, mtest.Sharded) mt.RunOpts("wrap mmapv1 error", errorOpts, func(mt mtest.T) { res, err := mt.DB.RunCommand(context.Background(), bson.D{{"serverStatus", 1}}).Raw() assert.Nil(mt, err, "serverStatus error: %v", err) storageEngine, ok := res.Lookup("storageEngine", "name").StringValueOK() if !ok \|\| storageEngine != "mmapv1" { mt.Skip("skipping because storage engine is not mmapv1") } _, err = mt.Coll.InsertOne(context.Background(), bson.D{{"x", 1}}) assert.Equal(mt, driver.ErrUnsupportedStorageEngine, err, "expected error %v, got %v", driver.ErrUnsupportedStorageEngine, err) }) standaloneOpts := mtest.NewOptions().Topologies(mtest.Single).CreateClient(false) mt.RunOpts("transaction number not sent on writes", standaloneOpts, func(mt mtest.T) { mt.Run("explicit session", func(mt mtest.T) { // Standalones do not support retryable writes and will error if a transaction number is sent sess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) defer sess.EndSession(context.Background()) mt.ClearEvents() err = mongo.WithSession(context.Background(), sess, func(ctx mongo.SessionContext) error { doc := bson.D{{"foo", 1}} _, err := mt.Coll.InsertOne(ctx, doc) return err }) assert.Nil(mt, err, "InsertOne error: %v", err) _, wantID := sess.ID().Lookup("id").Binary() command := mt.GetStartedEvent().Command lsid, err := command.LookupErr("lsid") assert.Nil(mt, err, "Error getting lsid: %v", err) _, gotID := lsid.Document().Lookup("id").Binary() assert.True(mt, bytes.Equal(wantID, gotID), "expected session ID %v, got %v", wantID, gotID) txnNumber, err := command.LookupErr("txnNumber") assert.NotNil(mt, err, "expected no txnNumber, got %v", txnNumber) }) mt.Run("implicit session", func(mt mtest.T) { // Standalones do not support retryable writes and will error if a transaction number is sent mt.ClearEvents() doc := bson.D{{"foo", 1}} _, err := mt.Coll.InsertOne(context.Background(), doc) assert.Nil(mt, err, "InsertOne error: %v", err) command := mt.GetStartedEvent().Command lsid, err := command.LookupErr("lsid") assert.Nil(mt, err, "Error getting lsid: %v", err) _, gotID := lsid.Document().Lookup("id").Binary() assert.NotNil(mt, gotID, "expected session ID, got nil") txnNumber, err := command.LookupErr("txnNumber") assert.NotNil(mt, err, "expected no txnNumber, got %v", txnNumber) }) }) tpm := eventtest.NewTestPoolMonitor() // Client options with MaxPoolSize of 1 and RetryWrites used per the test description. // Lower HeartbeatInterval used to speed the test up for any server that uses streaming // heartbeats. Only connect to first host in list for sharded clusters. hosts := mtest.ClusterConnString().Hosts pceOpts := options.Client().SetMaxPoolSize(1).SetRetryWrites(true). SetPoolMonitor(tpm.PoolMonitor).SetHeartbeatInterval(500 time.Millisecond). SetHosts(hosts[:1]) mtPceOpts := mtest.NewOptions().ClientOptions(pceOpts).MinServerVersion("4.3"). Topologies(mtest.ReplicaSet, mtest.Sharded) mt.RunOpts("PoolClearedError retryability", mtPceOpts, func(mt mtest.T) { // Force Find to block for 1 second once. mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"insert"}, ErrorCode: 91, BlockConnection: true, BlockTimeMS: 1000, ErrorLabels: &[]string{"RetryableWriteError"}, }, }) // Clear CMAP and command events. tpm.ClearEvents() mt.ClearEvents() // Perform an InsertOne on two different threads and assert both operations are // successful. var wg sync.WaitGroup for i := 0; i < 2; i++ { wg.Add(1) go func() { defer wg.Done() _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"x", 1}}) assert.Nil(mt, err, "InsertOne error: %v", err) }() } wg.Wait() // Gather GetSucceeded, GetFailed and PoolCleared pool events. events := tpm.Events(func(e event.PoolEvent) bool { getSucceeded := e.Type == event.GetSucceeded getFailed := e.Type == event.GetFailed poolCleared := e.Type == event.PoolCleared return getSucceeded \|\| getFailed \|\| poolCleared }) // Assert that first check out succeeds, pool is cleared, and second check // out fails due to connection error. assert.True(mt, len(events) >= 3, "expected at least 3 events, got %v", len(events)) assert.Equal(mt, event.GetSucceeded, events[0].Type, "expected ConnectionCheckedOut event, got %v", events[0].Type) assert.Equal(mt, event.PoolCleared, events[1].Type, "expected ConnectionPoolCleared event, got %v", events[1].Type) assert.Equal(mt, event.GetFailed, events[2].Type, "expected ConnectionCheckedOutFailed event, got %v", events[2].Type) assert.Equal(mt, event.ReasonConnectionErrored, events[2].Reason, "expected check out failure due to connection error, failed due to %q", events[2].Reason) // Assert that three insert CommandStartedEvents were observed. for i := 0; i < 3; i++ { cmdEvt := mt.GetStartedEvent() assert.NotNil(mt, cmdEvt, "expected an insert event, got nil") assert.Equal(mt, cmdEvt.CommandName, "insert", "expected an insert event, got a(n) %v event", cmdEvt.CommandName) } }) mtNWPOpts := mtest.NewOptions().MinServerVersion("6.0").Topologies(mtest.ReplicaSet) mt.RunOpts(fmt.Sprintf("%s label returns original error", driver.NoWritesPerformed), mtNWPOpts, func(mt mtest.T) { const shutdownInProgressErrorCode int32 = 91 const notWritablePrimaryErrorCode int32 = 10107 monitor := new(event.CommandMonitor) mt.ResetClient(options.Client().SetRetryWrites(true).SetMonitor(monitor)) // Configure a fail point for a "ShutdownInProgress" error. mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{Times: 1}, Data: mtest.FailPointData{ WriteConcernError: &mtest.WriteConcernErrorData{ Code: shutdownInProgressErrorCode, }, FailCommands: []string{"insert"}, }, }) // secondFailPointConfigured is used to determine if the conditions from the // shutdownInProgressErrorCode actually configures the "NoWritablePrimary" fail command. var secondFailPointConfigured bool //Set a command monitor on the client that configures a failpoint with a "NoWritesPerformed" monitor.Succeeded = func(_ context.Context, evt event.CommandSucceededEvent) { var errorCode int32 if wce := evt.Reply.Lookup("writeConcernError"); wce.Type == bsontype.EmbeddedDocument { var ok bool errorCode, ok = wce.Document().Lookup("code").Int32OK() if !ok { t.Fatalf("expected code to be an int32, got %v", wce.Document().Lookup("code").Type) return } } // Do not set a fail point if event was not a writeConcernError with an error code for // "ShutdownInProgress". if errorCode != shutdownInProgressErrorCode { return } mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{Times: 1}, Data: mtest.FailPointData{ ErrorCode: notWritablePrimaryErrorCode, ErrorLabels: &[]string{ driver.NoWritesPerformed, driver.RetryableWriteError, }, FailCommands: []string{"insert"}, }, }) secondFailPointConfigured = true } // Attempt to insert a document. _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"x", 1}}) require.True(mt, secondFailPointConfigured) // Assert that the "ShutdownInProgress" error is returned. require.True(mt, err.(mongo.WriteException).HasErrorCode(int(shutdownInProgressErrorCode))) }) mtOpts = mtest.NewOptions().Topologies(mtest.Sharded).MinServerVersion("4.2") mt.RunOpts("retrying in sharded cluster", mtOpts, func(mt mtest.T) { tests := []struct { name string // Note that setting this value greater than 2 will result in false // negatives. The current specification does not account for CSOT, which // might allow for an "infinite" number of retries over a period of time. // Because of this, we only track the "previous server". hostCount int failpointErrorCode int32 expectedFailCount int expectedSuccessCount int }{ { name: "retry on different mongos", hostCount: 2, failpointErrorCode: 6, // HostUnreachable expectedFailCount: 2, expectedSuccessCount: 0, }, { name: "retry on same mongos", hostCount: 1, failpointErrorCode: 6, // HostUnreachable expectedFailCount: 1, expectedSuccessCount: 1, }, } for _, tc := range tests { mt.Run(tc.name, func(mt mtest.T) { hosts := options.Client().ApplyURI(mtest.ClusterURI()).Hosts require.GreaterOrEqualf(mt, len(hosts), tc.hostCount, "test cluster must have at least %v mongos hosts", tc.hostCount) // Configure the failpoint options for each mongos. failPoint := mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"insert"}, ErrorLabels: &[]string{"RetryableWriteError"}, ErrorCode: tc.failpointErrorCode, CloseConnection: false, }, } // In order to ensure that each mongos in the hostCount-many mongos // hosts are tried at least once (i.e. failures are deprioritized), we // set a failpoint on all mongos hosts. The idea is that if we get // hostCount-many failures, then by the pigeonhole principal all mongos // hosts must have been tried. for i := 0; i < tc.hostCount; i++ { mt.ResetClient(options.Client().SetHosts([]string{hosts[i]})) mt.SetFailPoint(failPoint) // The automatic failpoint clearing may not clear failpoints set on // specific hosts, so manually clear the failpoint we set on the // specific mongos when the test is done. defer mt.ResetClient(options.Client().SetHosts([]string{hosts[i]})) defer mt.ClearFailPoints() } failCount := 0 successCount := 0 commandMonitor := &event.CommandMonitor{ Failed: func(context.Context, event.CommandFailedEvent) { failCount++ }, Succeeded: func(context.Context, event.CommandSucceededEvent) { successCount++ }, } // Reset the client with exactly hostCount-many mongos hosts. mt.ResetClient(options.Client(). SetHosts(hosts[:tc.hostCount]). SetRetryWrites(true). SetMonitor(commandMonitor)) _, _ = mt.Coll.InsertOne(context.Background(), bson.D{}) assert.Equal(mt, tc.expectedFailCount, failCount) assert.Equal(mt, tc.expectedSuccessCount, successCount) }) } }) }	13.63 KB	2025-05-25 12:27
📄 retryable_writes_spec_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "io/ioutil" "path" "testing" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/mongo/integration/mtest" ) const retryableWritesTestDir = "../../testdata/retryable-writes/legacy" type retryableWritesTestFile struct { RunOn []mtest.RunOnBlock `bson:"runOn"` Data []bson.Raw `bson:"data"` Tests []retryableWritesTest `bson:"tests"` } type retryableWritesTest struct { Description string `bson:"description"` ClientOptions bson.Raw `bson:"clientOptions"` UseMultipleMongoses bool `bson:"useMultipleMongoses"` FailPoint mtest.FailPoint `bson:"failPoint"` Operation crudOperation `bson:"operation"` Outcome crudOutcome `bson:"outcome"` } func TestRetryableWritesSpec(t testing.T) { for _, file := range jsonFilesInDir(t, retryableWritesTestDir) { t.Run(file, func(t testing.T) { runRetryableWritesFile(t, path.Join(retryableWritesTestDir, file)) }) } } func runRetryableWritesFile(t testing.T, filePath string) { content, err := ioutil.ReadFile(filePath) assert.Nil(t, err, "ReadFile error for %v: %v", filePath, err) var testFile retryableWritesTestFile err = bson.UnmarshalExtJSONWithRegistry(specTestRegistry, content, false, &testFile) assert.Nil(t, err, "UnmarshalExtJSONWithRegistry error: %v", err) mt := mtest.New(t, mtest.NewOptions().RunOn(testFile.RunOn...).CreateClient(false)) for _, test := range testFile.Tests { runRetryableWritesTest(mt, test, testFile) } } func runRetryableWritesTest(mt mtest.T, test retryableWritesTest, testFile retryableWritesTestFile) { // Use a low heartbeat frequency so the Client will quickly recover when using failpoints that cause SDAM state // changes. testClientOpts := createClientOptions(mt, test.ClientOptions) testClientOpts.SetHeartbeatInterval(defaultHeartbeatInterval) opts := mtest.NewOptions().ClientOptions(testClientOpts) if mtest.ClusterTopologyKind() == mtest.Sharded && !test.UseMultipleMongoses { // pin to a single mongos opts = opts.ClientType(mtest.Pinned) } mt.RunOpts(test.Description, opts, func(mt mtest.T) { // setup - insert test data and set fail point insertDocuments(mt, mt.Coll, testFile.Data) if test.FailPoint != nil { mt.SetFailPoint(*test.FailPoint) } // run operation and verify outcome/error runCrudOperation(mt, test.Description, test.Operation, test.Outcome) }) }	2.72 KB	2025-05-25 12:27
📄 sdam_error_handling_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 //go:build go1.13 // +build go1.13 package integration import ( "context" "errors" "fmt" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/eventtest" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" ) func TestSDAMErrorHandling(t testing.T) { mt := mtest.New(t, noClientOpts) baseClientOpts := func() options.ClientOptions { return options.Client(). ApplyURI(mtest.ClusterURI()). SetRetryWrites(false). SetWriteConcern(mtest.MajorityWc) } baseMtOpts := func() mtest.Options { mtOpts := mtest.NewOptions(). Topologies(mtest.ReplicaSet, mtest.Single). // Don't run on sharded clusters to avoid complexity of sharded failpoints. MinServerVersion("4.0"). // 4.0+ is required to use failpoints on replica sets. ClientOptions(baseClientOpts()) if mtest.ClusterTopologyKind() == mtest.Sharded { // Pin to a single mongos because the tests use failpoints. mtOpts.ClientType(mtest.Pinned) } return mtOpts } // Set min server version of 4.4 because the during-handshake tests use failpoint features introduced in 4.4 like // blockConnection and appName. mt.RunOpts("before handshake completes", baseMtOpts().Auth(true).MinServerVersion("4.4"), func(mt mtest.T) { mt.RunOpts("network errors", noClientOpts, func(mt mtest.T) { mt.Run("pool cleared on network timeout", func(mt mtest.T) { // Assert that the pool is cleared when a connection created by an application // operation thread encounters a timeout caused by socketTimeoutMS during // handshaking. appName := "authConnectTimeoutTest" // Set failpoint on saslContinue instead of saslStart because saslStart isn't done when using // speculative auth. mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"saslContinue"}, BlockConnection: true, BlockTimeMS: 150, AppName: appName, }, }) // Reset the client with the appName specified in the failpoint and the pool monitor. tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(baseClientOpts(). SetAppName(appName). SetPoolMonitor(tpm.PoolMonitor). // Set a 100ms socket timeout so that the saslContinue delay of 150ms causes a // timeout during socket read (i.e. a timeout not caused by the InsertOne context). SetSocketTimeout(100 * time.Millisecond)) // Use context.Background() so that the new connection will not time out due to an // operation-scoped timeout. _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"test", 1}}) assert.NotNil(mt, err, "expected InsertOne error, got nil") assert.True(mt, mongo.IsTimeout(err), "expected timeout error, got %v", err) assert.True(mt, mongo.IsNetworkError(err), "expected network error, got %v", err) // Assert that the pool is cleared within 2 seconds. assert.Soon(mt, func(ctx context.Context) { ticker := time.NewTicker(100 * time.Millisecond) defer ticker.Stop() for { select { case <-ticker.C: case <-ctx.Done(): return } if tpm.IsPoolCleared() { return } } }, 2time.Second) }) mt.RunOpts("pool cleared on non-timeout network error", noClientOpts, func(mt mtest.T) { mt.Run("background", func(mt mtest.T) { // Assert that the pool is cleared when a connection created by the background pool maintenance // routine encounters a non-timeout network error during handshaking. appName := "authNetworkErrorTestBackground" mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"saslContinue"}, CloseConnection: true, AppName: appName, }, }) // Reset the client with the appName specified in the failpoint. tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(baseClientOpts(). SetAppName(appName). SetPoolMonitor(tpm.PoolMonitor). // Set minPoolSize to enable the background pool maintenance goroutine. SetMinPoolSize(5)) // Assert that the pool is cleared within 2 seconds. assert.Soon(mt, func(ctx context.Context) { ticker := time.NewTicker(100 time.Millisecond) defer ticker.Stop() for { select { case <-ticker.C: case <-ctx.Done(): return } if tpm.IsPoolCleared() { return } } }, 2time.Second) }) mt.Run("foreground", func(mt mtest.T) { // Assert that the pool is cleared when a connection created by an application thread connection // checkout encounters a non-timeout network error during handshaking. appName := "authNetworkErrorTestForeground" mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"saslContinue"}, CloseConnection: true, AppName: appName, }, }) // Reset the client with the appName specified in the failpoint. tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(baseClientOpts().SetAppName(appName).SetPoolMonitor(tpm.PoolMonitor)) _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"x", 1}}) assert.NotNil(mt, err, "expected InsertOne error, got nil") assert.False(mt, mongo.IsTimeout(err), "expected non-timeout error, got %v", err) // Assert that the pool is cleared within 2 seconds. assert.Soon(mt, func(ctx context.Context) { ticker := time.NewTicker(100 * time.Millisecond) defer ticker.Stop() for { select { case <-ticker.C: case <-ctx.Done(): return } if tpm.IsPoolCleared() { return } } }, 2time.Second) }) }) }) }) mt.RunOpts("after handshake completes", baseMtOpts(), func(mt mtest.T) { mt.RunOpts("network errors", noClientOpts, func(mt mtest.T) { mt.Run("pool cleared on non-timeout network error", func(mt mtest.T) { appName := "afterHandshakeNetworkError" mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"insert"}, CloseConnection: true, AppName: appName, }, }) // Reset the client with the appName specified in the failpoint. tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(baseClientOpts().SetAppName(appName).SetPoolMonitor(tpm.PoolMonitor)) _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"test", 1}}) assert.NotNil(mt, err, "expected InsertOne error, got nil") assert.False(mt, mongo.IsTimeout(err), "expected non-timeout error, got %v", err) assert.True(mt, tpm.IsPoolCleared(), "expected pool to be cleared but was not") }) mt.Run("pool not cleared on timeout network error", func(mt mtest.T) { tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(baseClientOpts().SetPoolMonitor(tpm.PoolMonitor)) _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"x", 1}}) assert.Nil(mt, err, "InsertOne error: %v", err) filter := bson.M{ "$where": "function() { sleep(1000); return false; }", } timeoutCtx, cancel := context.WithTimeout(context.Background(), 100time.Millisecond) defer cancel() _, err = mt.Coll.Find(timeoutCtx, filter) assert.NotNil(mt, err, "expected Find error, got %v", err) assert.True(mt, mongo.IsTimeout(err), "expected timeout error, got %v", err) assert.False(mt, tpm.IsPoolCleared(), "expected pool to not be cleared but was") }) mt.Run("pool not cleared on context cancellation", func(mt mtest.T) { tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(baseClientOpts().SetPoolMonitor(tpm.PoolMonitor)) _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"x", 1}}) assert.Nil(mt, err, "InsertOne error: %v", err) findCtx, cancel := context.WithCancel(context.Background()) go func() { time.Sleep(100 time.Millisecond) cancel() }() filter := bson.M{ "$where": "function() { sleep(1000); return false; }", } _, err = mt.Coll.Find(findCtx, filter) assert.NotNil(mt, err, "expected Find error, got nil") assert.False(mt, mongo.IsTimeout(err), "expected non-timeout error, got %v", err) assert.True(mt, mongo.IsNetworkError(err), "expected network error, got %v", err) assert.True(mt, errors.Is(err, context.Canceled), "expected error %v to be context.Canceled", err) assert.False(mt, tpm.IsPoolCleared(), "expected pool to not be cleared but was") }) }) mt.RunOpts("server errors", noClientOpts, func(mt mtest.T) { // Integration tests for the SDAM error handling code path for errors in server response documents. These // errors can be part of the top-level document in ok:0 responses or in a nested writeConcernError document. // On 4.4, some state change errors include a topologyVersion field. Because we're triggering these errors // via failCommand, the topologyVersion does not actually change as it would in an actual state change. // This causes the SDAM error handling code path to think we've already handled this state change and // ignore the error because it's stale. To avoid this altogether, we cap the test to <= 4.2. serverErrorsMtOpts := baseMtOpts(). MinServerVersion("4.0"). // failCommand support MaxServerVersion("4.2"). ClientOptions(baseClientOpts().SetRetryWrites(false)) testCases := []struct { name string errorCode int32 // For shutdown errors, the pool is always cleared. For non-shutdown errors, the pool is only cleared // for pre-4.2 servers. isShutdownError bool }{ // "node is recovering" errors {"InterruptedAtShutdown", 11600, true}, {"InterruptedDueToReplStateChange, not shutdown", 11602, false}, {"NotPrimaryOrSecondary", 13436, false}, {"PrimarySteppedDown", 189, false}, {"ShutdownInProgress", 91, true}, // "not primary" errors {"NotPrimary", 10107, false}, {"NotPrimaryNoSecondaryOk", 13435, false}, } for _, tc := range testCases { mt.RunOpts(fmt.Sprintf("command error - %s", tc.name), serverErrorsMtOpts, func(mt mtest.T) { appName := fmt.Sprintf("command_error_%s", tc.name) // Cause the next insert to fail with an ok:0 response. mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"insert"}, ErrorCode: tc.errorCode, AppName: appName, }, }) // Reset the client with the appName specified in the failpoint. tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(baseClientOpts().SetAppName(appName).SetPoolMonitor(tpm.PoolMonitor)) runServerErrorsTest(mt, tc.isShutdownError, tpm) }) mt.RunOpts(fmt.Sprintf("write concern error - %s", tc.name), serverErrorsMtOpts, func(mt mtest.T) { appName := fmt.Sprintf("write_concern_error_%s", tc.name) // Cause the next insert to fail with a write concern error. mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1, }, Data: mtest.FailPointData{ FailCommands: []string{"insert"}, WriteConcernError: &mtest.WriteConcernErrorData{ Code: tc.errorCode, }, AppName: appName, }, }) // Reset the client with the appName specified in the failpoint. tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(baseClientOpts().SetAppName(appName).SetPoolMonitor(tpm.PoolMonitor)) runServerErrorsTest(mt, tc.isShutdownError, tpm) }) } }) }) } func runServerErrorsTest(mt mtest.T, isShutdownError bool, tpm *eventtest.TestPoolMonitor) { mt.Helper() _, err := mt.Coll.InsertOne(context.Background(), bson.D{{"x", 1}}) assert.NotNil(mt, err, "expected InsertOne error, got nil") // The pool should always be cleared for shutdown errors, regardless of server version. if isShutdownError { assert.True(mt, tpm.IsPoolCleared(), "expected pool to be cleared, but was not") return } // For non-shutdown errors, the pool is only cleared if the error is from a pre-4.2 server. wantCleared := mtest.CompareServerVersions(mtest.ServerVersion(), "4.2") < 0 gotCleared := tpm.IsPoolCleared() assert.Equal(mt, wantCleared, gotCleared, "expected pool to be cleared: %t; pool was cleared: %t", wantCleared, gotCleared) }	13.02 KB	2025-05-25 12:27
📄 sdam_prose_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "net" "os" "runtime" "testing" "time" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/handshake" "go.mongodb.org/mongo-driver/internal/require" "go.mongodb.org/mongo-driver/mongo/address" "go.mongodb.org/mongo-driver/mongo/description" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/x/mongo/driver/topology" ) func TestSDAMProse(t testing.T) { mt := mtest.New(t) // Server limits non-streaming heartbeats and explicit server transition checks to at most one // per 500ms. Set the test interval to 500ms to minimize the difference between the behavior of // streaming and non-streaming heartbeat intervals. heartbeatInterval := 500 time.Millisecond heartbeatIntervalClientOpts := options.Client(). SetHeartbeatInterval(heartbeatInterval) heartbeatIntervalMtOpts := mtest.NewOptions(). ClientOptions(heartbeatIntervalClientOpts). CreateCollection(false). ClientType(mtest.Proxy). MinServerVersion("4.4") // RTT Monitor / Streaming protocol is not supported for versions < 4.4. mt.RunOpts("heartbeats processed more frequently", heartbeatIntervalMtOpts, func(mt mtest.T) { // Test that setting heartbeat interval to 500ms causes the client to process heartbeats // approximately every 500ms instead of the default 10s. Note that a Client doesn't // guarantee that it will process heartbeats exactly every 500ms, just that it will wait at // least 500ms between heartbeats (and should process heartbeats more frequently for shorter // interval settings). // // For number of nodes N, interval I, and duration D, a Client should process at most X // operations: // // X = (N (2 handshakes + D/I heartbeats + D/I RTTs)) // // Assert that a Client processes the expected number of operations for heartbeats sent at // an interval between I and 2I to account for different actual heartbeat intervals under // different runtime conditions. // Measure the actual amount of time between the start of the test and when we inspect the // sent messages. The sleep duration will be at least the specified duration but // possibly longer, which could lead to extra heartbeat messages, so account for that in // the assertions. if len(os.Getenv("DOCKER_RUNNING")) > 0 { mt.Skip("skipping test in docker environment") } start := time.Now() time.Sleep(2 time.Second) messages := mt.GetProxiedMessages() duration := time.Since(start) numNodes := len(options.Client().ApplyURI(mtest.ClusterURI()).Hosts) maxExpected := numNodes * (2 + 2int(duration/heartbeatInterval)) minExpected := numNodes (2 + 2int(duration/(heartbeatInterval2))) assert.True( mt, len(messages) >= minExpected && len(messages) <= maxExpected, "expected number of messages to be in range [%d, %d], got %d"+ " (num nodes = %d, duration = %v, interval = %v)", minExpected, maxExpected, len(messages), numNodes, duration, heartbeatInterval) }) mt.RunOpts("rtt tests", noClientOpts, func(mt mtest.T) { clientOpts := options.Client(). SetHeartbeatInterval(500 time.Millisecond). SetAppName("streamingRttTest") mtOpts := mtest.NewOptions(). MinServerVersion("4.4"). ClientOptions(clientOpts) mt.RunOpts("rtt is continuously updated", mtOpts, func(mt mtest.T) { // Test that the RTT monitor updates the RTT for server descriptions. // The server has been discovered by the create command issued by mtest. Sleep for two seconds to allow // multiple heartbeats to finish. testTopology := getTopologyFromClient(mt.Client) time.Sleep(2 time.Second) for _, serverDesc := range testTopology.Description().Servers { assert.NotEqual(mt, description.Unknown, serverDesc.Kind, "server %v is Unknown", serverDesc) assert.True(mt, serverDesc.AverageRTTSet, "AverageRTTSet for server description %v is false", serverDesc) if runtime.GOOS != "windows" { // Windows has a lower time resolution than other platforms, which causes the reported RTT to be // 0 if it's below some threshold. The assertion above already confirms that the RTT is set to // a value, so we can skip this assertion on Windows. assert.True(mt, serverDesc.AverageRTT > 0, "server description %v has 0 RTT", serverDesc) } } // Force hello requests to block for 500ms and wait until a server's average RTT goes over 250ms. mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 1000, }, Data: mtest.FailPointData{ FailCommands: []string{handshake.LegacyHello, "hello"}, BlockConnection: true, BlockTimeMS: 500, AppName: "streamingRttTest", }, }) callback := func(ctx context.Context) { for { // Stop loop if callback has been canceled. select { case <-ctx.Done(): return default: } // We don't know which server received the failpoint command, so we wait until any of the server // RTTs cross the threshold. for _, serverDesc := range testTopology.Description().Servers { if serverDesc.AverageRTT > 250time.Millisecond { return } } // The next update will be in ~500ms. time.Sleep(500 time.Millisecond) } } assert.Soon(t, callback, defaultCallbackTimeout) }) }) mt.RunOpts("client waits between failed Hellos", mtest.NewOptions().MinServerVersion("4.9").Topologies(mtest.Single), func(mt mtest.T) { // Force hello requests to fail 5 times. mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 5, }, Data: mtest.FailPointData{ FailCommands: []string{handshake.LegacyHello, "hello"}, ErrorCode: 1234, AppName: "SDAMMinHeartbeatFrequencyTest", }, }) // Reset client options to use direct connection, app name, and 5s SS timeout. clientOpts := options.Client().SetDirect(true). SetAppName("SDAMMinHeartbeatFrequencyTest"). SetServerSelectionTimeout(5 time.Second) mt.ResetClient(clientOpts) // Assert that Ping completes successfully within 2 to 3.5 seconds. start := time.Now() err := mt.Client.Ping(context.Background(), nil) assert.Nil(mt, err, "Ping error: %v", err) pingTime := time.Since(start) assert.True(mt, pingTime > 2000time.Millisecond && pingTime < 3500time.Millisecond, "expected Ping to take between 2 and 3.5 seconds, took %v seconds", pingTime.Seconds()) }) } func TestServerHeartbeatStartedEvent(t testing.T) { t.Run("emits the first HeartbeatStartedEvent before the monitoring socket was created", func(t testing.T) { t.Parallel() const address = address.Address("localhost:9999") expectedEvents := []string{ "serverHeartbeatStartedEvent", "client connected", "client hello received", "serverHeartbeatFailedEvent", } events := make(chan string) listener, err := net.Listen("tcp", address.String()) assert.NoError(t, err) defer listener.Close() go func() { conn, err := listener.Accept() assert.NoError(t, err) defer conn.Close() events <- "client connected" _, _ = conn.Read(nil) events <- "client hello received" }() server := topology.NewServer( address, primitive.NewObjectID(), topology.WithServerMonitor(func(event.ServerMonitor) event.ServerMonitor { return &event.ServerMonitor{ ServerHeartbeatStarted: func(e event.ServerHeartbeatStartedEvent) { events <- "serverHeartbeatStartedEvent" }, ServerHeartbeatFailed: func(e event.ServerHeartbeatFailedEvent) { events <- "serverHeartbeatFailedEvent" }, } }), ) require.NoError(t, server.Connect(nil)) ticker := time.NewTicker(5 * time.Second) defer ticker.Stop() actualEvents := make([]string, 0, len(expectedEvents)) for len(actualEvents) < len(expectedEvents) { select { case event := <-events: actualEvents = append(actualEvents, event) case <-ticker.C: assert.FailNow(t, "timed out for incoming event") } } assert.Equal(t, expectedEvents, actualEvents) }) }	8.38 KB	2025-05-25 12:27
📄 search_index_prose_test.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "os" "sync" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/require" "go.mongodb.org/mongo-driver/internal/uuid" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" ) func TestSearchIndexProse(t testing.T) { t.Parallel() const timeout = 5 time.Minute uri := os.Getenv("TEST_INDEX_URI") if uri == "" { t.Skip("skipping") } opts := options.Client().ApplyURI(uri).SetTimeout(timeout) mt := mtest.New(t, mtest.NewOptions().ClientOptions(opts).MinServerVersion("7.0").Topologies(mtest.ReplicaSet)) mt.Run("case 1: Driver can successfully create and list search indexes", func(mt mtest.T) { ctx := context.Background() _, err := mt.Coll.InsertOne(ctx, bson.D{}) require.NoError(mt, err, "failed to insert") view := mt.Coll.SearchIndexes() definition := bson.D{{"mappings", bson.D{{"dynamic", false}}}} searchName := "test-search-index" opts := options.SearchIndexes().SetName(searchName) index, err := view.CreateOne(ctx, mongo.SearchIndexModel{ Definition: definition, Options: opts, }) require.NoError(mt, err, "failed to create index") require.Equal(mt, searchName, index, "unmatched name") var doc bson.Raw for doc == nil { cursor, err := view.List(ctx, opts) require.NoError(mt, err, "failed to list") if !cursor.Next(ctx) { break } if cursor.Current.Lookup("queryable").Boolean() { doc = cursor.Current } else { t.Logf("cursor: %s, sleep 5 seconds...", cursor.Current.String()) time.Sleep(5 time.Second) } } require.NotNil(mt, doc, "got empty document") assert.Equal(mt, searchName, doc.Lookup("name").StringValue(), "unmatched name") expected, err := bson.Marshal(definition) require.NoError(mt, err, "failed to marshal definition") actual := doc.Lookup("latestDefinition").Value assert.Equal(mt, expected, actual, "unmatched definition") }) mt.Run("case 2: Driver can successfully create multiple indexes in batch", func(mt mtest.T) { ctx := context.Background() _, err := mt.Coll.InsertOne(ctx, bson.D{}) require.NoError(mt, err, "failed to insert") view := mt.Coll.SearchIndexes() definition := bson.D{{"mappings", bson.D{{"dynamic", false}}}} models := []mongo.SearchIndexModel{ { Definition: definition, Options: options.SearchIndexes().SetName("test-search-index-1"), }, { Definition: definition, Options: options.SearchIndexes().SetName("test-search-index-2"), }, } indexes, err := view.CreateMany(ctx, models) require.NoError(mt, err, "failed to create index") require.Equal(mt, len(indexes), 2, "expected 2 indexes") for _, model := range models { require.Contains(mt, indexes, model.Options.Name) } getDocument := func(opts options.SearchIndexesOptions) bson.Raw { for { cursor, err := view.List(ctx, opts) require.NoError(mt, err, "failed to list") if !cursor.Next(ctx) { return nil } if cursor.Current.Lookup("queryable").Boolean() { return cursor.Current } t.Logf("cursor: %s, sleep 5 seconds...", cursor.Current.String()) time.Sleep(5 time.Second) } } var wg sync.WaitGroup wg.Add(len(models)) for i := range models { go func(opts options.SearchIndexesOptions) { defer wg.Done() doc := getDocument(opts) require.NotNil(mt, doc, "got empty document") assert.Equal(mt, opts.Name, doc.Lookup("name").StringValue(), "unmatched name") expected, err := bson.Marshal(definition) require.NoError(mt, err, "failed to marshal definition") actual := doc.Lookup("latestDefinition").Value assert.Equal(mt, expected, actual, "unmatched definition") }(models[i].Options) } wg.Wait() }) mt.Run("case 3: Driver can successfully drop search indexes", func(mt mtest.T) { ctx := context.Background() _, err := mt.Coll.InsertOne(ctx, bson.D{}) require.NoError(mt, err, "failed to insert") view := mt.Coll.SearchIndexes() definition := bson.D{{"mappings", bson.D{{"dynamic", false}}}} searchName := "test-search-index" opts := options.SearchIndexes().SetName(searchName) index, err := view.CreateOne(ctx, mongo.SearchIndexModel{ Definition: definition, Options: opts, }) require.NoError(mt, err, "failed to create index") require.Equal(mt, searchName, index, "unmatched name") var doc bson.Raw for doc == nil { cursor, err := view.List(ctx, opts) require.NoError(mt, err, "failed to list") if !cursor.Next(ctx) { break } if cursor.Current.Lookup("queryable").Boolean() { doc = cursor.Current } else { t.Logf("cursor: %s, sleep 5 seconds...", cursor.Current.String()) time.Sleep(5 time.Second) } } require.NotNil(mt, doc, "got empty document") require.Equal(mt, searchName, doc.Lookup("name").StringValue(), "unmatched name") err = view.DropOne(ctx, searchName) require.NoError(mt, err, "failed to drop index") for { cursor, err := view.List(ctx, opts) require.NoError(mt, err, "failed to list") if !cursor.Next(ctx) { break } t.Logf("cursor: %s, sleep 5 seconds...", cursor.Current.String()) time.Sleep(5 * time.Second) } }) mt.Run("case 4: Driver can update a search index", func(mt mtest.T) { ctx := context.Background() _, err := mt.Coll.InsertOne(ctx, bson.D{}) require.NoError(mt, err, "failed to insert") view := mt.Coll.SearchIndexes() definition := bson.D{{"mappings", bson.D{{"dynamic", false}}}} searchName := "test-search-index" opts := options.SearchIndexes().SetName(searchName) index, err := view.CreateOne(ctx, mongo.SearchIndexModel{ Definition: definition, Options: opts, }) require.NoError(mt, err, "failed to create index") require.Equal(mt, searchName, index, "unmatched name") getDocument := func() bson.Raw { for { cursor, err := view.List(ctx, opts) require.NoError(mt, err, "failed to list") if !cursor.Next(ctx) { return nil } if cursor.Current.Lookup("queryable").Boolean() { return cursor.Current } t.Logf("cursor: %s, sleep 5 seconds...", cursor.Current.String()) time.Sleep(5 time.Second) } } doc := getDocument() require.NotNil(mt, doc, "got empty document") require.Equal(mt, searchName, doc.Lookup("name").StringValue(), "unmatched name") definition = bson.D{{"mappings", bson.D{{"dynamic", true}}}} err = view.UpdateOne(ctx, searchName, definition) require.NoError(mt, err, "failed to drop index") doc = getDocument() require.NotNil(mt, doc, "got empty document") assert.Equal(mt, searchName, doc.Lookup("name").StringValue(), "unmatched name") assert.Equal(mt, "READY", doc.Lookup("status").StringValue(), "unexpected status") expected, err := bson.Marshal(definition) require.NoError(mt, err, "failed to marshal definition") actual := doc.Lookup("latestDefinition").Value assert.Equal(mt, expected, actual, "unmatched definition") }) mt.Run("case 5: dropSearchIndex suppresses namespace not found errors", func(mt *mtest.T) { ctx := context.Background() id, err := uuid.New() require.NoError(mt, err) collection := mt.CreateCollection(mtest.Collection{ Name: id.String(), }, false) err = collection.SearchIndexes().DropOne(ctx, "foo") require.NoError(mt, err) }) }	7.56 KB	2025-05-25 12:27
📄 server_selection_prose_test.go // Copyright (C) MongoDB, Inc. 2022-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "sync" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/eventtest" "go.mongodb.org/mongo-driver/internal/require" "go.mongodb.org/mongo-driver/mongo/description" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" ) type saturatedConnections map[uint64]bool // saturatedHosts is used to maintain information about events with specific host+pool combinations. type saturatedHosts map[string]saturatedConnections func (set saturatedHosts) add(host string, connectionID uint64) { if set[host] == nil { set[host] = make(saturatedConnections) } set[host][connectionID] = true } // isSaturated returns true when each client on the cluster URI has a tolerable number of ready connections. func (set saturatedHosts) isSaturated(tolerance uint64) bool { for _, host := range options.Client().ApplyURI(mtest.ClusterURI()).Hosts { if cxns := set[host]; cxns == nil \|\| uint64(len(cxns)) < tolerance { return false } } return true } // awaitSaturation uses CMAP events to ensure that the client's connection pools for N-mongoses have been saturated. // The qualification for a host to be "saturated" is for each host on the client to have a tolerable number of ready // connections. func awaitSaturation(ctx context.Context, mt mtest.T, monitor eventtest.TestPoolMonitor, tolerance uint64) error { set := make(saturatedHosts) var err error for !set.isSaturated(tolerance) { if err = ctx.Err(); err != nil { break } if err = mt.Coll.FindOne(ctx, bson.D{}).Err(); err != nil { break } monitor.Events(func(evt event.PoolEvent) bool { // Add host only when the connection is ready for use. if evt.Type == event.ConnectionReady { set.add(evt.Address, evt.ConnectionID) } return true }) } return err } // runsServerSelection will run opCount-many `FindOne` operations within threadCount-many go routines. The purpose of // this is to test the reliability of the server selection algorithm, which can be verified with the `counts` map and // `event.PoolEvent` slice. func runsServerSelection(mt mtest.T, monitor eventtest.TestPoolMonitor, threadCount, opCount int) (map[string]int, []event.PoolEvent) { var wg sync.WaitGroup for i := 0; i < threadCount; i++ { wg.Add(1) go func() { defer wg.Done() for i := 0; i < opCount; i++ { res := mt.Coll.FindOne(context.Background(), bson.D{}) assert.NoError(mt.T, res.Err(), "FindOne() error for Collection '%s'", mt.Coll.Name()) } }() } wg.Wait() // Get all checkOut events and calculate the number of times each server was selected. The prose test spec says to // use command monitoring events, but those don't include the server address, so use checkOut events instead. checkOutEvents := monitor.Events(func(evt event.PoolEvent) bool { return evt.Type == event.GetStarted }) counts := make(map[string]int) for _, evt := range checkOutEvents { counts[evt.Address]++ } assert.Equal(mt, 2, len(counts), "expected exactly 2 server addresses") return counts, checkOutEvents } // TestServerSelectionProse implements the Server Selection prose tests: // https://github.com/mongodb/specifications/blob/master/source/server-selection/server-selection-tests.rst func TestServerSelectionProse(t testing.T) { const maxPoolSize = 10 const localThreshold = 30 * time.Second mt := mtest.New(t, mtest.NewOptions().CreateClient(false)) mtOpts := mtest.NewOptions().Topologies(mtest.Sharded).MinServerVersion("4.9") mt.RunOpts("operationCount-based selection within latency window, with failpoint", mtOpts, func(mt mtest.T) { _, err := mt.Coll.InsertOne(context.Background(), bson.D{}) require.NoError(mt, err, "InsertOne() error") hosts := options.Client().ApplyURI(mtest.ClusterURI()).Hosts require.GreaterOrEqualf(mt, len(hosts), 2, "test cluster must have at least 2 mongos hosts") // Set a failpoint on a specific mongos host that delays all "find" commands for 500ms. We // need to know which mongos we set the failpoint on for our assertions later. failpointHost := hosts[0] mt.ResetClient(options.Client(). SetHosts([]string{failpointHost})) mt.SetFailPoint(mtest.FailPoint{ ConfigureFailPoint: "failCommand", Mode: mtest.FailPointMode{ Times: 10000, }, Data: mtest.FailPointData{ FailCommands: []string{"find"}, BlockConnection: true, BlockTimeMS: 500, AppName: "loadBalancingTest", }, }) // The automatic failpoint clearing may not clear failpoints set on specific hosts, so // manually clear the failpoint we set on the specific mongos when the test is done. defer func() { mt.ResetClient(options.Client(). SetHosts([]string{failpointHost})) mt.ClearFailPoints() }() // Reset the client with exactly 2 mongos hosts. Use a ServerMonitor to wait for both mongos // host descriptions to move from kind "Unknown" to kind "Mongos". topologyEvents := make(chan event.TopologyDescriptionChangedEvent, 10) tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(options.Client(). SetLocalThreshold(localThreshold). SetMaxPoolSize(maxPoolSize). SetMinPoolSize(maxPoolSize). SetHosts(hosts[:2]). SetPoolMonitor(tpm.PoolMonitor). SetAppName("loadBalancingTest"). SetServerMonitor(&event.ServerMonitor{ TopologyDescriptionChanged: func(evt event.TopologyDescriptionChangedEvent) { topologyEvents <- evt }, })) for evt := range topologyEvents { servers := evt.NewDescription.Servers if len(servers) == 2 && servers[0].Kind == description.Mongos && servers[1].Kind == description.Mongos { break } } ctx, cancel := context.WithTimeout(context.Background(), 5time.Second) defer cancel() if err := awaitSaturation(ctx, mt, tpm, maxPoolSize); err != nil { mt.Fatalf("Error awaiting saturation: %v", err.Error()) } counts, checkOutEvents := runsServerSelection(mt, tpm, 10, 10) // Calculate the frequency that the server with the failpoint was selected. Assert that it // was selected less than 25% of the time. frequency := float64(counts[failpointHost]) / float64(len(checkOutEvents)) assert.Lessf(mt, frequency, 0.25, "expected failpoint host %q to be selected less than 25%% of the time", failpointHost) }) mtOpts = mtest.NewOptions().Topologies(mtest.Sharded) mt.RunOpts("operationCount-based selection within latency window, no failpoint", mtOpts, func(mt mtest.T) { // TODO(GODRIVER-2842): Fix and unskip this test case. mt.Skip("Test fails frequently, skipping. See GODRIVER-2842") _, err := mt.Coll.InsertOne(context.Background(), bson.D{}) require.NoError(mt, err, "InsertOne() error") hosts := options.Client().ApplyURI(mtest.ClusterURI()).Hosts require.GreaterOrEqualf(mt, len(hosts), 2, "test cluster must have at least 2 mongos hosts") // Reset the client with exactly 2 mongos hosts. Use a ServerMonitor to wait for both mongos // host descriptions to move from kind "Unknown" to kind "Mongos". topologyEvents := make(chan event.TopologyDescriptionChangedEvent, 10) tpm := eventtest.NewTestPoolMonitor() mt.ResetClient(options.Client(). SetHosts(hosts[:2]). SetPoolMonitor(tpm.PoolMonitor). SetLocalThreshold(localThreshold). SetMaxPoolSize(maxPoolSize). SetMinPoolSize(maxPoolSize). SetServerMonitor(&event.ServerMonitor{ TopologyDescriptionChanged: func(evt event.TopologyDescriptionChangedEvent) { topologyEvents <- evt }, })) for evt := range topologyEvents { servers := evt.NewDescription.Servers if len(servers) == 2 && servers[0].Kind == description.Mongos && servers[1].Kind == description.Mongos { break } } ctx, cancel := context.WithTimeout(context.Background(), 5time.Second) defer cancel() if err := awaitSaturation(ctx, mt, tpm, maxPoolSize); err != nil { mt.Fatalf("Error awaiting saturation: %v", err.Error()) } counts, checkOutEvents := runsServerSelection(mt, tpm, 10, 100) // Calculate the frequency that each server was selected. Assert that each server was // selected 50% (+/- 10%) of the time. for addr, count := range counts { frequency := float64(count) / float64(len(checkOutEvents)) assert.InDeltaf(mt, 0.5, frequency, 0.1, "expected server %q to be selected 50%% (+/- 10%%) of the time, but was selected %v%% of the time", addr, frequency*100) } }) }	8.63 KB	2025-05-25 12:27
📄 sessions_mongocryptd_prose_test.go // Copyright (C) MongoDB, Inc. 2023-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "fmt" "net" "net/url" "os/exec" "strconv" "testing" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/require" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) type mongocryptdProcess struct { cmd exec.Cmd } // start will start a mongocryptd server in the background on the OS. func (p mongocryptdProcess) start(port int) error { args := []string{ "mongocryptd", "--port", strconv.Itoa(port), } p.cmd = exec.Command(args[0], args[1:]...) //nolint:gosec p.cmd.Stderr = p.cmd.Stdout return p.cmd.Start() } // close will kill the underlying process on the command. func (p mongocryptdProcess) close() error { if p.cmd.Process == nil { return nil } if err := p.cmd.Process.Kill(); err != nil { return fmt.Errorf("failed to terminate mongocryptd process: %w", err) } // Release instead of wait to avoid blocking in CI. err := p.cmd.Process.Release() if err != nil { return fmt.Errorf("failed to release mongocryptd: %w", err) } return nil } // newTestSessionMongocryptdProseClient will Create the client using the mongo // API rather than mtest. mtest will attempt to create a collection as // a database operation, which will not work on a mongocryptd server. A // mongocryptd server does not support operations on a database. func newTestSessionMongocryptdProseClient(mt mtest.T) mongo.Client { const mongocryptdPort = 27022 // Monitor the lsid value on commands. If an operation run in any // subtests contains an lsid, then the Go Driver wire message // construction has incorrectly interpreted that // LogicalSessionTimeoutMinutes was returned by the server on handshake. cmdMonitor := &event.CommandMonitor{ Started: func(_ context.Context, evt event.CommandStartedEvent) { _, err := evt.Command.LookupErr("lsid") assert.ErrorIs(mt, err, bsoncore.ErrElementNotFound) }, } uri := &url.URL{ Scheme: "mongodb", Host: net.JoinHostPort("localhost", strconv.Itoa(mongocryptdPort)), } proc := mongocryptdProcess{} // Start a mongocryptd server. err := proc.start(mongocryptdPort) require.NoError(mt, err, "failed to create a mongocryptd process: %v", err) mt.Cleanup(func() { err := proc.close() require.NoError(mt, err, "failed to close mongocryptd: %v", err) }) clientOpts := options. Client(). ApplyURI(uri.String()). SetMonitor(cmdMonitor) ctx := context.Background() client, err := mongo.Connect(ctx, clientOpts) require.NoError(mt, err, "could not connect to mongocryptd: %v", err) return client } func TestSessionsMongocryptdProse(t testing.T) { mtOpts := mtest.NewOptions(). MinServerVersion("4.2"). Topologies(mtest.ReplicaSet, mtest.Sharded). CreateCollection(false). CreateClient(false) // Create a new instance of mtest (MongoDB testing framework) for this // test and configure it to control server versions. mt := mtest.New(t, mtOpts) proseTest18 := "18. implicit session is ignored if connection does not support sessions" mt.RunOpts(proseTest18, mtOpts, func(mt mtest.T) { client := newTestSessionMongocryptdProseClient(mt) mt.Cleanup(func() { err := client.Disconnect(context.Background()) require.NoError(mt, err, "mongocryptd client could not disconnect: %v", err) }) coll := client.Database("db").Collection("coll") // Send a read command to the server (e.g., findOne), ignoring // any errors from the server response mt.RunOpts("read", mtOpts, func(_ mtest.T) { _ = coll.FindOne(context.Background(), bson.D{{"x", 1}}) }) // Send a write command to the server (e.g., insertOne), // ignoring any errors from the server response mt.RunOpts("write", mtOpts, func(_ mtest.T) { _, _ = coll.InsertOne(context.Background(), bson.D{{"x", 1}}) }) }) proseTest19 := "19. explicit session raises an error if connection does not support sessions" mt.RunOpts(proseTest19, mtOpts, func(mt mtest.T) { client := newTestSessionMongocryptdProseClient(mt) mt.Cleanup(func() { err := client.Disconnect(context.Background()) require.NoError(mt, err, "mongocryptd client could not disconnect: %v", err) }) // Create a new explicit session by calling startSession (this // MUST NOT error). session, err := client.StartSession() require.NoError(mt, err, "expected error to be nil, got %v", err) defer session.EndSession(context.Background()) sessionCtx := mongo.NewSessionContext(context.TODO(), session) err = session.StartTransaction() require.NoError(mt, err, "expected error to be nil, got %v", err) coll := client.Database("db").Collection("coll") // Attempt to send a read command to the server (e.g., findOne) // with the explicit session passed in. mt.RunOpts("read", mtOpts, func(mt mtest.T) { // Assert that a client-side error is generated // indicating that sessions are not supported res := coll.FindOne(sessionCtx, bson.D{{"x", 1}}) assert.EqualError(mt, res.Err(), "current topology does not support sessions") }) // Attempt to send a write command to the server (e.g., // ``insertOne``) with the explicit session passed in. mt.RunOpts("write", mtOpts, func(mt *mtest.T) { // Assert that a client-side error is generated // indicating that sessions are not supported. res := coll.FindOne(sessionCtx, bson.D{{"x", 1}}) assert.EqualError(mt, res.Err(), "current topology does not support sessions") }) }) }	5.78 KB	2025-05-25 12:27
📄 sessions_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "bytes" "context" "errors" "fmt" "reflect" "sync" "testing" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/require" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/mongo/readpref" "go.mongodb.org/mongo-driver/mongo/writeconcern" "go.mongodb.org/mongo-driver/x/mongo/driver/session" "golang.org/x/sync/errgroup" ) func TestSessionPool(t testing.T) { mt := mtest.New(t, mtest.NewOptions().MinServerVersion("3.6").CreateClient(false)) mt.Run("last use time updated", func(mt mtest.T) { sess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) defer sess.EndSession(context.Background()) initialLastUsedTime := getSessionLastUsedTime(mt, sess) err = mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { return mt.Client.Ping(sc, readpref.Primary()) }) assert.Nil(mt, err, "WithSession error: %v", err) newLastUsedTime := getSessionLastUsedTime(mt, sess) assert.True(mt, newLastUsedTime.After(initialLastUsedTime), "last used time %s is not after the initial last used time %s", newLastUsedTime, initialLastUsedTime) }) } func TestSessions(t testing.T) { mtOpts := mtest.NewOptions().MinServerVersion("3.6").Topologies(mtest.ReplicaSet, mtest.Sharded). CreateClient(false) mt := mtest.New(t, mtOpts) mt.Run("imperative API", func(mt mtest.T) { mt.Run("round trip Session object", func(mt mtest.T) { // Roundtrip a Session object through NewSessionContext/ContextFromSession and assert that it is correctly // stored/retrieved. sess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) defer sess.EndSession(context.Background()) ctx := mongo.NewSessionContext(context.Background(), sess) assert.Equal(mt, sess.ID(), ctx.ID(), "expected Session ID %v, got %v", sess.ID(), ctx.ID()) gotSess := mongo.SessionFromContext(ctx) assert.NotNil(mt, gotSess, "expected SessionFromContext to return non-nil value, got nil") assert.Equal(mt, sess.ID(), gotSess.ID(), "expected Session ID %v, got %v", sess.ID(), gotSess.ID()) }) txnOpts := mtest.NewOptions().RunOn( mtest.RunOnBlock{Topology: []mtest.TopologyKind{mtest.ReplicaSet}, MinServerVersion: "4.0"}, mtest.RunOnBlock{Topology: []mtest.TopologyKind{mtest.Sharded}, MinServerVersion: "4.2"}, ) mt.RunOpts("run transaction", txnOpts, func(mt mtest.T) { // Test that the imperative sessions API can be used to run a transaction. createSessionContext := func(mt mtest.T) mongo.SessionContext { sess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) return mongo.NewSessionContext(context.Background(), sess) } ctx := createSessionContext(mt) sess := mongo.SessionFromContext(ctx) assert.NotNil(mt, sess, "expected SessionFromContext to return non-nil value, got nil") defer sess.EndSession(context.Background()) err := sess.StartTransaction() assert.Nil(mt, err, "StartTransaction error: %v", err) numDocs := 2 for i := 0; i < numDocs; i++ { _, err = mt.Coll.InsertOne(ctx, bson.D{{"x", 1}}) assert.Nil(mt, err, "InsertOne error at index %d: %v", i, err) } // Assert that the collection count is 0 before committing and numDocs after. This tests that the InsertOne // calls were actually executed in the transaction because the pre-commit count does not include them. assertCollectionCount(mt, 0) err = sess.CommitTransaction(ctx) assert.Nil(mt, err, "CommitTransaction error: %v", err) assertCollectionCount(mt, int64(numDocs)) }) }) unackWcOpts := options.Collection().SetWriteConcern(writeconcern.New(writeconcern.W(0))) mt.RunOpts("unacknowledged write", mtest.NewOptions().CollectionOptions(unackWcOpts), func(mt mtest.T) { // unacknowledged write during a session should result in an error sess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) defer sess.EndSession(context.Background()) err = mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { _, err := mt.Coll.InsertOne(sc, bson.D{{"x", 1}}) return err }) assert.Equal(mt, err, mongo.ErrUnacknowledgedWrite, "expected ErrUnacknowledgedWrite on unacknowledged write in session, got %v", err) }) // Regression test for GODRIVER-2533. Note that this test assumes the race // detector is enabled (GODRIVER-2072). mt.Run("NumberSessionsInProgress data race", func(mt mtest.T) { // Use two goroutines to execute a few simultaneous runs of NumberSessionsInProgress // and a basic collection operation (CountDocuments). var wg sync.WaitGroup wg.Add(2) go func() { defer wg.Done() for i := 0; i < 100; i++ { time.Sleep(100 time.Microsecond) _ = mt.Client.NumberSessionsInProgress() } }() go func() { defer wg.Done() for i := 0; i < 100; i++ { time.Sleep(100 * time.Microsecond) _, err := mt.Coll.CountDocuments(context.Background(), bson.D{}) assert.Nil(mt, err, "CountDocument error: %v", err) } }() wg.Wait() }) } func TestSessionsProse(t testing.T) { mtOpts := mtest. NewOptions(). MinServerVersion("3.6"). Topologies(mtest.ReplicaSet, mtest.Sharded). CreateClient(false) mt := mtest.New(t, mtOpts) hosts := options.Client().ApplyURI(mtest.ClusterURI()).Hosts mt.Run("1 setting both snapshot and causalConsistency to true is not allowed", func(mt mtest.T) { // causalConsistency and snapshot are mutually exclusive sessOpts := options.Session().SetCausalConsistency(true).SetSnapshot(true) _, err := mt.Client.StartSession(sessOpts) assert.NotNil(mt, err, "expected StartSession error, got nil") expectedErr := errors.New("causal consistency and snapshot cannot both be set for a session") assert.Equal(mt, expectedErr, err, "expected error %v, got %v", expectedErr, err) }) mt.Run("2 pool is LIFO", func(mt mtest.T) { aSess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) bSess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) // end the sessions to return them to the pool aSess.EndSession(context.Background()) bSess.EndSession(context.Background()) firstSess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) defer firstSess.EndSession(context.Background()) want := bSess.ID() got := firstSess.ID() assert.True(mt, sessionIDsEqual(mt, want, got), "expected session ID %v, got %v", want, got) secondSess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) defer secondSess.EndSession(context.Background()) want = aSess.ID() got = secondSess.ID() assert.True(mt, sessionIDsEqual(mt, want, got), "expected session ID %v, got %v", want, got) }) // Pin to a single mongos so heartbeats/handshakes to other mongoses // won't cause errors. clusterTimeOpts := mtest.NewOptions(). ClientOptions(options.Client().SetHeartbeatInterval(50 time.Second)). ClientType(mtest.Pinned). CreateClient(false) mt.RunOpts("3 clusterTime in commands", clusterTimeOpts, func(mt mtest.T) { serverStatus := sessionFunction{"server status", "database", "RunCommand", []interface{}{bson.D{{"serverStatus", 1}}}} insert := sessionFunction{"insert one", "collection", "InsertOne", []interface{}{bson.D{{"x", 1}}}} agg := sessionFunction{"aggregate", "collection", "Aggregate", []interface{}{mongo.Pipeline{}}} find := sessionFunction{"find", "collection", "Find", []interface{}{bson.D{}}} sessionFunctions := []sessionFunction{serverStatus, insert, agg, find} for _, sf := range sessionFunctions { mt.Run(sf.name, func(mt mtest.T) { err := sf.execute(mt, nil) assert.Nil(mt, err, "%v error: %v", sf.name, err) // assert $clusterTime was sent to server started := mt.GetStartedEvent() assert.NotNil(mt, started, "expected started event, got nil") _, err = started.Command.LookupErr("$clusterTime") assert.Nil(mt, err, "$clusterTime not sent") // record response cluster time succeeded := mt.GetSucceededEvent() assert.NotNil(mt, succeeded, "expected succeeded event, got nil") replyClusterTimeVal, err := succeeded.Reply.LookupErr("$clusterTime") assert.Nil(mt, err, "$clusterTime not found in response") // call function again err = sf.execute(mt, nil) assert.Nil(mt, err, "%v error: %v", sf.name, err) // find cluster time sent to server and assert it is the same as the one in the previous response sentClusterTimeVal, err := mt.GetStartedEvent().Command.LookupErr("$clusterTime") assert.Nil(mt, err, "$clusterTime not sent") replyClusterTimeDoc := replyClusterTimeVal.Document() sentClusterTimeDoc := sentClusterTimeVal.Document() assert.Equal(mt, replyClusterTimeDoc, sentClusterTimeDoc, "expected cluster time %v, got %v", replyClusterTimeDoc, sentClusterTimeDoc) }) } }) mt.RunOpts("4 explicit and implicit session arguments", noClientOpts, func(mt mtest.T) { // lsid is included in commands with explicit and implicit sessions sessionFunctions := createFunctionsSlice() for _, sf := range sessionFunctions { mt.Run(sf.name, func(mt mtest.T) { // explicit session sess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) defer sess.EndSession(context.Background()) mt.ClearEvents() _ = sf.execute(mt, sess) // don't check error because we only care about lsid _, wantID := sess.ID().Lookup("id").Binary() gotID := extractSentSessionID(mt) assert.True(mt, bytes.Equal(wantID, gotID), "expected session ID %v, got %v", wantID, gotID) // implicit session _ = sf.execute(mt, nil) gotID = extractSentSessionID(mt) assert.NotNil(mt, gotID, "expected lsid, got nil") }) } }) mt.Run("5 session argument is for the right client", func(mt mtest.T) { // a session can only be used in commands associated with the client that created it sessionFunctions := createFunctionsSlice() sess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) defer sess.EndSession(context.Background()) for _, sf := range sessionFunctions { mt.Run(sf.name, func(mt mtest.T) { err = sf.execute(mt, sess) assert.Equal(mt, mongo.ErrWrongClient, err, "expected error %v, got %v", mongo.ErrWrongClient, err) }) } }) const proseTest6 = "6 no further operations can be performed using a session after endSession has been called" mt.RunOpts(proseTest6, noClientOpts, func(mt mtest.T) { // an ended session cannot be used in commands sessionFunctions := createFunctionsSlice() for _, sf := range sessionFunctions { mt.Run(sf.name, func(mt mtest.T) { sess, err := mt.Client.StartSession() assert.Nil(mt, err, "StartSession error: %v", err) sess.EndSession(context.Background()) err = sf.execute(mt, sess) assert.Equal(mt, session.ErrSessionEnded, err, "expected error %v, got %v", session.ErrSessionEnded, err) }) } }) mt.Run("7 authenticating as multiple users suppresses implicit sessions", func(mt mtest.T) { mt.Skip("Go Driver does not allow simultaneous authentication with multiple users.") }) mt.Run("8 client side cursor that exhausts the results on the initial query immediately returns the implicit session to the pool", func(mt mtest.T) { // implicit sessions are returned to the server session pool doc := bson.D{{"x", 1}} _, err := mt.Coll.InsertOne(context.Background(), doc) assert.Nil(mt, err, "InsertOne error: %v", err) _, err = mt.Coll.InsertOne(context.Background(), doc) assert.Nil(mt, err, "InsertOne error: %v", err) // create a cursor that will hold onto an implicit session and record the sent session ID mt.ClearEvents() cursor, err := mt.Coll.Find(context.Background(), bson.D{}) assert.Nil(mt, err, "Find error: %v", err) findID := extractSentSessionID(mt) assert.True(mt, cursor.Next(context.Background()), "expected Next true, got false") // execute another operation and verify the find session ID was reused _, err = mt.Coll.DeleteOne(context.Background(), bson.D{}) assert.Nil(mt, err, "DeleteOne error: %v", err) deleteID := extractSentSessionID(mt) assert.Equal(mt, findID, deleteID, "expected session ID %v, got %v", findID, deleteID) }) mt.Run("9 client side cursor that exhausts the results after a getMore immediately returns the implicit session to the pool", func(mt mtest.T) { // Client-side cursor that exhausts the results after a getMore immediately returns the implicit session to the pool. var docs []interface{} for i := 0; i < 5; i++ { docs = append(docs, bson.D{{"x", i}}) } _, err := mt.Coll.InsertMany(context.Background(), docs) assert.Nil(mt, err, "InsertMany error: %v", err) // run a find that will hold onto the implicit session and record the session ID mt.ClearEvents() cursor, err := mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetBatchSize(3)) assert.Nil(mt, err, "Find error: %v", err) findID := extractSentSessionID(mt) // iterate past 4 documents, forcing a getMore. session should be returned to pool after getMore for i := 0; i < 4; i++ { assert.True(mt, cursor.Next(context.Background()), "Next returned false on iteration %v", i) } // execute another operation and verify the find session ID was reused _, err = mt.Coll.DeleteOne(context.Background(), bson.D{}) assert.Nil(mt, err, "DeleteOne error: %v", err) deleteID := extractSentSessionID(mt) assert.Equal(mt, findID, deleteID, "expected session ID %v, got %v", findID, deleteID) }) mt.Run("10 no remaining sessions are checked out after each functional test", func(mt mtest.T) { mt.Skip("This is tested individually in each functional test.") }) mt.Run("11 for every combination of topology and readPreference, ensure that find and getMore both send the same session id", func(mt mtest.T) { var docs []interface{} for i := 0; i < 3; i++ { docs = append(docs, bson.D{{"x", i}}) } _, err := mt.Coll.InsertMany(context.Background(), docs) assert.Nil(mt, err, "InsertMany error: %v", err) // run a find that will hold onto an implicit session and record the session ID mt.ClearEvents() cursor, err := mt.Coll.Find(context.Background(), bson.D{}, options.Find().SetBatchSize(2)) assert.Nil(mt, err, "Find error: %v", err) findID := extractSentSessionID(mt) assert.NotNil(mt, findID, "expected session ID for find, got nil") // iterate over all documents and record the session ID of the getMore for i := 0; i < 3; i++ { assert.True(mt, cursor.Next(context.Background()), "Next returned false on iteration %v", i) } getMoreID := extractSentSessionID(mt) assert.Equal(mt, findID, getMoreID, "expected session ID %v, got %v", findID, getMoreID) }) sessallocopts := mtest.NewOptions().ClientOptions(options.Client().SetMaxPoolSize(1).SetRetryWrites(true). SetHosts(hosts[:1])) mt.RunOpts("14 implicit session allocation", sessallocopts, func(mt mtest.T) { // TODO(GODRIVER-2844): Fix and unskip this test case. mt.Skip("Test fails frequently, skipping. See GODRIVER-2844") ops := map[string]func(ctx context.Context) error{ "insert": func(ctx context.Context) error { _, err := mt.Coll.InsertOne(ctx, bson.D{}) return err }, "delete": func(ctx context.Context) error { _, err := mt.Coll.DeleteOne(ctx, bson.D{}) return err }, "update": func(ctx context.Context) error { _, err := mt.Coll.UpdateOne(ctx, bson.D{}, bson.D{{"$set", bson.D{{"a", 1}}}}) return err }, "bulkWrite": func(ctx context.Context) error { model := mongo.NewUpdateOneModel(). SetFilter(bson.D{}). SetUpdate(bson.D{{"$set", bson.D{{"a", 1}}}}) _, err := mt.Coll.BulkWrite(ctx, []mongo.WriteModel{model}) return err }, "findOneAndDelete": func(ctx context.Context) error { result := mt.Coll.FindOneAndDelete(ctx, bson.D{}) if err := result.Err(); err != nil && !errors.Is(err, mongo.ErrNoDocuments) { return err } return nil }, "findOneAndUpdate": func(ctx context.Context) error { result := mt.Coll.FindOneAndUpdate(ctx, bson.D{}, bson.D{{"$set", bson.D{{"a", 1}}}}) if err := result.Err(); err != nil && !errors.Is(err, mongo.ErrNoDocuments) { return err } return nil }, "findOneAndReplace": func(ctx context.Context) error { result := mt.Coll.FindOneAndReplace(ctx, bson.D{}, bson.D{{"a", 1}}) if err := result.Err(); err != nil && !errors.Is(err, mongo.ErrNoDocuments) { return err } return nil }, "find": func(ctx context.Context) error { cursor, err := mt.Coll.Find(ctx, bson.D{}) if err != nil { return err } return cursor.All(ctx, &bson.A{}) }, } // maintainedOneSession asserts that exactly one session is used for all operations at least once // across the retries of this test. var maintainedOneSession bool // minimumSessionCount asserts the least amount of sessions used over all the retries of the // operations. For example, if we retry 5 times we could result in session use { 1, 2, 1, 1, 6 }. In // this case, minimumSessionCount should be 1. var minimumSessionCount int // limitedSessionUse asserts that the number of allocated sessions is strictly less than the number of // concurrent operations in every retry of this test. In this instance it would be less than (but NOT // equal to the number of operations). limitedSessionUse := true retrycount := 5 for i := 1; i <= retrycount; i++ { errs, ctx := errgroup.WithContext(context.Background()) // Execute the ops list concurrently. for cmd, op := range ops { op := op cmd := cmd errs.Go(func() error { if err := op(ctx); err != nil { return fmt.Errorf("error running %s operation: %w", cmd, err) } return nil }) } err := errs.Wait() assert.Nil(mt, err, "expected no error, got: %v", err) // Get all started events and collect them by the session ID. set := make(map[string]bool) for _, event := range mt.GetAllStartedEvents() { lsid := event.Command.Lookup("lsid") set[lsid.String()] = true } setSize := len(set) if setSize == 1 { maintainedOneSession = true } else if setSize < minimumSessionCount \|\| minimumSessionCount == 0 { // record the minimum number of sessions we used over all retries. minimumSessionCount = setSize } if setSize >= len(ops) { limitedSessionUse = false } } oneSessMsg := "expected one session across all %v operations for at least 1/%v retries, got: %v" assert.True(mt, maintainedOneSession, oneSessMsg, len(ops), retrycount, minimumSessionCount) limitedSessMsg := "expected session count to be less than the number of operations: %v" assert.True(mt, limitedSessionUse, limitedSessMsg, len(ops)) }) } type sessionFunction struct { name string target string fnName string params []interface{} // should not include context } func (sf sessionFunction) execute(mt mtest.T, sess mongo.Session) error { var target reflect.Value switch sf.target { case "client": target = reflect.ValueOf(mt.Client) case "database": // use a different database for drops because any executed after the drop will get "database not found" // errors on sharded clusters if sf.name != "drop database" { target = reflect.ValueOf(mt.DB) break } target = reflect.ValueOf(mt.Client.Database("sessionsTestsDropDatabase")) case "collection": target = reflect.ValueOf(mt.Coll) case "indexView": target = reflect.ValueOf(mt.Coll.Indexes()) default: mt.Fatalf("unrecognized target: %v", sf.target) } fn := target.MethodByName(sf.fnName) paramsValues := interfaceSliceToValueSlice(sf.params) if sess != nil { return mongo.WithSession(context.Background(), sess, func(sc mongo.SessionContext) error { valueArgs := []reflect.Value{reflect.ValueOf(sc)} valueArgs = append(valueArgs, paramsValues...) returnValues := fn.Call(valueArgs) return extractReturnError(returnValues) }) } valueArgs := []reflect.Value{reflect.ValueOf(context.Background())} valueArgs = append(valueArgs, paramsValues...) returnValues := fn.Call(valueArgs) return extractReturnError(returnValues) } func createFunctionsSlice() []sessionFunction { insertManyDocs := []interface{}{bson.D{{"x", 1}}} fooIndex := mongo.IndexModel{ Keys: bson.D{{"foo", -1}}, Options: options.Index().SetName("fooIndex"), } manyIndexes := []mongo.IndexModel{fooIndex} updateDoc := bson.D{{"$inc", bson.D{{"x", 1}}}} return []sessionFunction{ {"list databases", "client", "ListDatabases", []interface{}{bson.D{}}}, {"insert one", "collection", "InsertOne", []interface{}{bson.D{{"x", 1}}}}, {"insert many", "collection", "InsertMany", []interface{}{insertManyDocs}}, {"delete one", "collection", "DeleteOne", []interface{}{bson.D{}}}, {"delete many", "collection", "DeleteMany", []interface{}{bson.D{}}}, {"update one", "collection", "UpdateOne", []interface{}{bson.D{}, updateDoc}}, {"update many", "collection", "UpdateMany", []interface{}{bson.D{}, updateDoc}}, {"replace one", "collection", "ReplaceOne", []interface{}{bson.D{}, bson.D{}}}, {"aggregate", "collection", "Aggregate", []interface{}{mongo.Pipeline{}}}, {"estimated document count", "collection", "EstimatedDocumentCount", nil}, {"distinct", "collection", "Distinct", []interface{}{"field", bson.D{}}}, {"find", "collection", "Find", []interface{}{bson.D{}}}, {"find one and delete", "collection", "FindOneAndDelete", []interface{}{bson.D{}}}, {"find one and replace", "collection", "FindOneAndReplace", []interface{}{bson.D{}, bson.D{}}}, {"find one and update", "collection", "FindOneAndUpdate", []interface{}{bson.D{}, updateDoc}}, {"drop collection", "collection", "Drop", nil}, {"list collections", "database", "ListCollections", []interface{}{bson.D{}}}, {"drop database", "database", "Drop", nil}, {"create one index", "indexView", "CreateOne", []interface{}{fooIndex}}, {"create many indexes", "indexView", "CreateMany", []interface{}{manyIndexes}}, {"drop one index", "indexView", "DropOne", []interface{}{"barIndex"}}, {"drop all indexes", "indexView", "DropAll", nil}, {"list indexes", "indexView", "List", nil}, } } func assertCollectionCount(mt mtest.T, expectedCount int64) { mt.Helper() count, err := mt.Coll.CountDocuments(context.Background(), bson.D{}) require.NoError(mt, err, "CountDocuments error") assert.Equal(mt, expectedCount, count, "expected CountDocuments result %v, got %v", expectedCount, count) } func sessionIDsEqual(mt mtest.T, id1, id2 bson.Raw) bool { first, err := id1.LookupErr("id") assert.Nil(mt, err, "id not found in document %v", id1) second, err := id2.LookupErr("id") assert.Nil(mt, err, "id not found in document %v", id2) _, firstUUID := first.Binary() _, secondUUID := second.Binary() return bytes.Equal(firstUUID, secondUUID) } func interfaceSliceToValueSlice(args []interface{}) []reflect.Value { vals := make([]reflect.Value, 0, len(args)) for _, arg := range args { vals = append(vals, reflect.ValueOf(arg)) } return vals } func extractReturnError(returnValues []reflect.Value) error { errVal := returnValues[len(returnValues)-1] switch converted := errVal.Interface().(type) { case error: return converted case mongo.SingleResult: return converted.Err() default: return nil } } func extractSentSessionID(mt mtest.T) []byte { event := mt.GetStartedEvent() if event == nil { return nil } lsid, err := event.Command.LookupErr("lsid") if err != nil { return nil } _, data := lsid.Document().Lookup("id").Binary() return data } func getSessionLastUsedTime(mt mtest.T, sess mongo.Session) time.Time { xsess, ok := sess.(mongo.XSession) assert.True(mt, ok, "expected session to implement mongo.XSession, but got %T", sess) return xsess.ClientSession().LastUsed }	24.01 KB	2025-05-25 12:27
📁 unified	-	2025-05-25 12:27
📄 unified_runner_events_helper_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "sync" "time" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/mongo/address" "go.mongodb.org/mongo-driver/mongo/description" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/readpref" "go.mongodb.org/mongo-driver/x/mongo/driver/topology" ) // Helper functions for the operations in the unified spec test runner that require assertions about SDAM and connection // pool events. var ( poolEventTypesMap = map[string]string{ "PoolClearedEvent": event.PoolCleared, } defaultCallbackTimeout = 10 * time.Second ) // unifiedRunnerEventMonitor monitors connection pool-related events. type unifiedRunnerEventMonitor struct { poolEventCount map[string]int poolEventCountLock sync.Mutex sdamMonitor event.ServerMonitor serverMarkedUnknownCount int serverMarkedUnknownCountLock sync.Mutex } func newUnifiedRunnerEventMonitor() unifiedRunnerEventMonitor { urem := unifiedRunnerEventMonitor{ poolEventCount: make(map[string]int), } urem.sdamMonitor = &event.ServerMonitor{ ServerDescriptionChanged: (func(e event.ServerDescriptionChangedEvent) { urem.serverMarkedUnknownCountLock.Lock() defer urem.serverMarkedUnknownCountLock.Unlock() // Spec tests only ever handle ServerMarkedUnknown ServerDescriptionChangedEvents // for the time being. if e.NewDescription.Kind == description.Unknown { urem.serverMarkedUnknownCount++ } }), } return &urem } // handlePoolEvent can be used as the event handler for a connection pool monitor. func (u unifiedRunnerEventMonitor) handlePoolEvent(evt event.PoolEvent) { u.poolEventCountLock.Lock() defer u.poolEventCountLock.Unlock() u.poolEventCount[evt.Type]++ } // getPoolEventCount returns the number of pool events of the given type, or 0 if no events were recorded. func (u unifiedRunnerEventMonitor) getPoolEventCount(eventType string) int { u.poolEventCountLock.Lock() defer u.poolEventCountLock.Unlock() mappedType := poolEventTypesMap[eventType] return u.poolEventCount[mappedType] } // getServerMarkedUnknownEvent returns the number of ServerMarkedUnknownEvents, or 0 if none were recorded. func (u unifiedRunnerEventMonitor) getServerMarkedUnknownCount() int { u.serverMarkedUnknownCountLock.Lock() defer u.serverMarkedUnknownCountLock.Unlock() return u.serverMarkedUnknownCount } func waitForEvent(mt mtest.T, test testCase, op operation) { eventType := op.Arguments.Lookup("event").StringValue() expectedCount := int(op.Arguments.Lookup("count").Int32()) callback := func(ctx context.Context) { for { // Stop loop if callback has been canceled. select { case <-ctx.Done(): return default: } var count int // Spec tests only ever wait for ServerMarkedUnknown SDAM events for the time being. if eventType == "ServerMarkedUnknownEvent" { count = test.monitor.getServerMarkedUnknownCount() } else { count = test.monitor.getPoolEventCount(eventType) } if count >= expectedCount { return } time.Sleep(100 * time.Millisecond) } } assert.Soon(mt, callback, defaultCallbackTimeout) } func assertEventCount(mt mtest.T, testCase testCase, op operation) { eventType := op.Arguments.Lookup("event").StringValue() expectedCount := int(op.Arguments.Lookup("count").Int32()) var gotCount int // Spec tests only ever assert ServerMarkedUnknown SDAM events for the time being. if eventType == "ServerMarkedUnknownEvent" { gotCount = testCase.monitor.getServerMarkedUnknownCount() } else { gotCount = testCase.monitor.getPoolEventCount(eventType) } assert.Equal(mt, expectedCount, gotCount, "expected count %d for event %s, got %d", expectedCount, eventType, gotCount) } func recordPrimary(mt mtest.T, testCase testCase) { testCase.recordedPrimary = getPrimaryAddress(mt, testCase.testTopology, true) } func waitForPrimaryChange(mt mtest.T, testCase testCase, op operation) { callback := func(ctx context.Context) { for { // Stop loop if callback has been canceled. select { case <-ctx.Done(): return default: } if getPrimaryAddress(mt, testCase.testTopology, false) != testCase.recordedPrimary { return } } } timeout := convertValueToMilliseconds(mt, op.Arguments.Lookup("timeoutMS")) assert.Soon(mt, callback, timeout) } // getPrimaryAddress returns the address of the current primary. If failFast is true, the server selection fast path // is used and the function will fail if the fast path doesn't return a server. func getPrimaryAddress(mt mtest.T, topo topology.Topology, failFast bool) address.Address { mt.Helper() ctx, cancel := context.WithCancel(context.Background()) defer cancel() if failFast { cancel() } primary, err := topo.SelectServer(ctx, description.ReadPrefSelector(readpref.Primary())) assert.Nil(mt, err, "SelectServer error: %v", err) return primary.(*topology.SelectedServer).Description().Addr }	5.21 KB	2025-05-25 12:27
📄 unified_runner_thread_helpers_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "fmt" "sync" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/mongo/integration/mtest" ) // Helper functions for the operations in the unified spec test runner that require creating and synchronizing // background goroutines. // backgroundRoutine represents a background goroutine that can execute operations. The goroutine reads operations from // a channel and executes them in order. It exits when an operation with name exitRoutineOperationName is read. If any // of the operations error, all future operations passed to the routine are skipped. The first error is reported by the // stop() function. type backgroundRoutine struct { operations chan operation mt mtest.T testCase testCase wg sync.WaitGroup err error } func newBackgroundRoutine(mt mtest.T, testCase testCase) backgroundRoutine { routine := &backgroundRoutine{ operations: make(chan operation, 10), mt: mt, testCase: testCase, } return routine } func (b backgroundRoutine) start() { b.wg.Add(1) go func() { defer b.wg.Done() for op := range b.operations { if b.err != nil { continue } if err := runOperation(b.mt, b.testCase, op, nil, nil); err != nil { b.err = fmt.Errorf("error running operation %s: %w", op.Name, err) } } }() } func (b backgroundRoutine) stop() error { close(b.operations) b.wg.Wait() return b.err } func (b backgroundRoutine) addOperation(op operation) bool { select { case b.operations <- op: return true default: return false } } func startThread(mt mtest.T, testCase testCase, op operation) { routine := newBackgroundRoutine(mt, testCase) testCase.routinesMap.Store(getThreadName(op), routine) routine.start() } func runOnThread(mt mtest.T, testCase testCase, op operation) { routineName := getThreadName(op) routineVal, ok := testCase.routinesMap.Load(routineName) assert.True(mt, ok, "no background routine found with name %s", routineName) routine := routineVal.(backgroundRoutine) var routineOperation operation operationDoc := op.Arguments.Lookup("operation") err := bson.UnmarshalWithRegistry(specTestRegistry, operationDoc.Document(), &routineOperation) assert.Nil(mt, err, "error creating operation for runOnThread: %v", err) ok = routine.addOperation(&routineOperation) assert.True(mt, ok, "failed to add operation %s to routine %s", routineOperation.Name, routineName) } func waitForThread(mt mtest.T, testCase testCase, op operation) { name := getThreadName(op) routineVal, ok := testCase.routinesMap.Load(name) assert.True(mt, ok, "no background routine found with name %s", name) err := routineVal.(backgroundRoutine).stop() testCase.routinesMap.Delete(name) assert.Nil(mt, err, "error on background routine %s: %v", name, err) } func getThreadName(op *operation) string { return op.Arguments.Lookup("name").StringValue() }	3.17 KB	2025-05-25 12:27
📄 unified_spec_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package integration import ( "context" "errors" "fmt" "io/ioutil" "os" "path" "reflect" "sync" "testing" "time" "unsafe" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsonrw" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/event" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/bsonutil" "go.mongodb.org/mongo-driver/internal/integtest" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/address" "go.mongodb.org/mongo-driver/mongo/gridfs" "go.mongodb.org/mongo-driver/mongo/integration/mtest" "go.mongodb.org/mongo-driver/mongo/options" "go.mongodb.org/mongo-driver/mongo/readconcern" "go.mongodb.org/mongo-driver/mongo/readpref" "go.mongodb.org/mongo-driver/x/mongo/driver/session" "go.mongodb.org/mongo-driver/x/mongo/driver/topology" ) const ( gridFSFiles = "fs.files" gridFSChunks = "fs.chunks" spec1403SkipReason = "servers less than 4.2 do not have mongocryptd; see SPEC-1403" godriver2123SkipReason = "failpoints and timeouts together cause failures; see GODRIVER-2123" godriver2413SkipReason = "encryptedFields argument is not supported on Collection.Drop; see GODRIVER-2413" ) var ( defaultHeartbeatInterval = 50 * time.Millisecond skippedTestDescriptions = map[string]string{ // SPEC-1403: This test checks to see if the correct error is thrown when auto encrypting with a server < 4.2. // Currently, the test will fail because a server < 4.2 wouldn't have mongocryptd, so Client construction // would fail with a mongocryptd spawn error. "operation fails with maxWireVersion < 8": spec1403SkipReason, // GODRIVER-2123: The two tests below use a failpoint and a socket or server selection timeout. // The timeout causes the eventual clearing of the failpoint in the test runner to fail with an // i/o timeout. "Ignore network timeout error on find": godriver2123SkipReason, "Network error on minPoolSize background creation": godriver2123SkipReason, "CreateCollection from encryptedFields.": godriver2413SkipReason, "DropCollection from encryptedFields": godriver2413SkipReason, "DropCollection from remote encryptedFields": godriver2413SkipReason, } ) type testFile struct { RunOn []mtest.RunOnBlock `bson:"runOn"` DatabaseName string `bson:"database_name"` CollectionName string `bson:"collection_name"` BucketName string `bson:"bucket_name"` Data testData `bson:"data"` JSONSchema bson.Raw `bson:"json_schema"` KeyVaultData []bson.Raw `bson:"key_vault_data"` Tests []testCase `bson:"tests"` EncryptedFields bson.Raw `bson:"encrypted_fields"` } type testData struct { Documents []bson.Raw GridFSData struct { Files []bson.Raw `bson:"fs.files"` Chunks []bson.Raw `bson:"fs.chunks"` } } // custom decoder for testData type func decodeTestData(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error { switch vr.Type() { case bsontype.Array: docsVal := val.FieldByName("Documents") decoder, err := dc.Registry.LookupDecoder(docsVal.Type()) if err != nil { return err } return decoder.DecodeValue(dc, vr, docsVal) case bsontype.EmbeddedDocument: gridfsDataVal := val.FieldByName("GridFSData") decoder, err := dc.Registry.LookupDecoder(gridfsDataVal.Type()) if err != nil { return err } return decoder.DecodeValue(dc, vr, gridfsDataVal) } return nil } type testCase struct { Description string `bson:"description"` SkipReason string `bson:"skipReason"` FailPoint bson.Raw `bson:"failPoint"` ClientOptions bson.Raw `bson:"clientOptions"` SessionOptions bson.Raw `bson:"sessionOptions"` Operations []operation `bson:"operations"` Expectations []expectation `bson:"expectations"` UseMultipleMongoses bool `bson:"useMultipleMongoses"` Outcome outcome `bson:"outcome"` // set in code if the test is a GridFS test chunkSize int32 bucket gridfs.Bucket // set in code to track test context testTopology topology.Topology recordedPrimary address.Address monitor unifiedRunnerEventMonitor routinesMap sync.Map // maps thread name to backgroundRoutine } type operation struct { Name string `bson:"name"` Object string `bson:"object"` CollectionOptions bson.Raw `bson:"collectionOptions"` DatabaseOptions bson.Raw `bson:"databaseOptions"` Result interface{} `bson:"result"` Arguments bson.Raw `bson:"arguments"` Error bool `bson:"error"` CommandName string `bson:"command_name"` // set in code after determining whether or not result represents an error opError operationError } type expectation struct { CommandStartedEvent struct { CommandName string `bson:"command_name"` DatabaseName string `bson:"database_name"` Command bson.Raw `bson:"command"` Extra map[string]interface{} `bson:",inline"` } `bson:"command_started_event"` CommandSucceededEvent struct { CommandName string `bson:"command_name"` Reply bson.Raw `bson:"reply"` Extra map[string]interface{} `bson:",inline"` } `bson:"command_succeeded_event"` CommandFailedEvent struct { CommandName string `bson:"command_name"` Extra map[string]interface{} `bson:",inline"` } `bson:"command_failed_event"` } type outcome struct { Collection outcomeCollection `bson:"collection"` } type outcomeCollection struct { Name string `bson:"name"` Data interface{} `bson:"data"` } type operationError struct { ErrorContains string `bson:"errorContains"` ErrorCodeName string `bson:"errorCodeName"` ErrorLabelsContain []string `bson:"errorLabelsContain"` ErrorLabelsOmit []string `bson:"errorLabelsOmit"` } const dataPath string = "../../testdata/" var directories = []string{ "transactions/legacy", "convenient-transactions", "retryable-reads", "read-write-concern/operation", "server-discovery-and-monitoring/integration", "atlas-data-lake-testing", } var checkOutcomeOpts = options.Collection().SetReadPreference(readpref.Primary()).SetReadConcern(readconcern.Local()) var specTestRegistry = bson.NewRegistryBuilder(). RegisterTypeMapEntry(bson.TypeEmbeddedDocument, reflect.TypeOf(bson.Raw{})). RegisterTypeDecoder(reflect.TypeOf(testData{}), bsoncodec.ValueDecoderFunc(decodeTestData)).Build() func TestUnifiedSpecs(t testing.T) { for _, specDir := range directories { t.Run(specDir, func(t testing.T) { for _, fileName := range jsonFilesInDir(t, path.Join(dataPath, specDir)) { t.Run(fileName, func(t testing.T) { runSpecTestFile(t, specDir, fileName) }) } }) } } // specDir: name of directory for a spec in the data/ folder // fileName: name of test file in specDir func runSpecTestFile(t testing.T, specDir, fileName string) { filePath := path.Join(dataPath, specDir, fileName) content, err := ioutil.ReadFile(filePath) assert.Nil(t, err, "unable to read spec test file %v: %v", filePath, err) var testFile testFile err = bson.UnmarshalExtJSONWithRegistry(specTestRegistry, content, false, &testFile) assert.Nil(t, err, "unable to unmarshal spec test file at %v: %v", filePath, err) // create mtest wrapper and skip if needed mtOpts := mtest.NewOptions(). RunOn(testFile.RunOn...). CreateClient(false) if specDir == "atlas-data-lake-testing" { mtOpts.AtlasDataLake(true) } mt := mtest.New(t, mtOpts) for _, test := range testFile.Tests { runSpecTestCase(mt, test, testFile) } } func runSpecTestCase(mt mtest.T, test testCase, testFile testFile) { opts := mtest.NewOptions().DatabaseName(testFile.DatabaseName).CollectionName(testFile.CollectionName) if mtest.ClusterTopologyKind() == mtest.Sharded && !test.UseMultipleMongoses { // pin to a single mongos opts = opts.ClientType(mtest.Pinned) } cco := options.CreateCollection() if len(testFile.JSONSchema) > 0 { validator := bson.D{ {"$jsonSchema", testFile.JSONSchema}, } cco.SetValidator(validator) } if len(testFile.EncryptedFields) > 0 { cco.SetEncryptedFields(testFile.EncryptedFields) } opts.CollectionCreateOptions(cco) // Start the test without setting client options so the setup will be done with a default client. mt.RunOpts(test.Description, opts, func(mt mtest.T) { if len(test.SkipReason) > 0 { mt.Skip(test.SkipReason) } if skipReason, ok := skippedTestDescriptions[test.Description]; ok { mt.Skipf("skipping due to known failure: %v", skipReason) } // work around for SERVER-39704: run a non-transactional distinct against each shard in a sharded cluster if mtest.ClusterTopologyKind() == mtest.Sharded && test.Description == "distinct" { err := runCommandOnAllServers(func(mongosClient mongo.Client) error { coll := mongosClient.Database(mt.DB.Name()).Collection(mt.Coll.Name()) _, err := coll.Distinct(context.Background(), "x", bson.D{}) return err }) assert.Nil(mt, err, "error running distinct against all mongoses: %v", err) } // Defer killSessions to ensure it runs regardless of the state of the test because the client has already // been created and the collection drop in mongotest will hang for transactions to be aborted (60 seconds) // in error cases. defer killSessions(mt) // Test setup: create collections that are tracked by mtest, insert test data, and set the failpoint. setupTest(mt, &testFile, test) if test.FailPoint != nil { mt.SetFailPointFromDocument(test.FailPoint) } // Reset the client using the client options specified in the test. testClientOpts := createClientOptions(mt, test.ClientOptions) // If AutoEncryptionOptions is set and AutoEncryption isn't disabled (neither // bypassAutoEncryption nor bypassQueryAnalysis are true), then add extra options to load // the crypt_shared library. if testClientOpts.AutoEncryptionOptions != nil { bypassAutoEncryption := testClientOpts.AutoEncryptionOptions.BypassAutoEncryption != nil && testClientOpts.AutoEncryptionOptions.BypassAutoEncryption bypassQueryAnalysis := testClientOpts.AutoEncryptionOptions.BypassQueryAnalysis != nil && testClientOpts.AutoEncryptionOptions.BypassQueryAnalysis if !bypassAutoEncryption && !bypassQueryAnalysis { if testClientOpts.AutoEncryptionOptions.ExtraOptions == nil { testClientOpts.AutoEncryptionOptions.ExtraOptions = make(map[string]interface{}) } for k, v := range getCryptSharedLibExtraOptions() { testClientOpts.AutoEncryptionOptions.ExtraOptions[k] = v } } } test.monitor = newUnifiedRunnerEventMonitor() testClientOpts.SetPoolMonitor(&event.PoolMonitor{ Event: test.monitor.handlePoolEvent, }) testClientOpts.SetServerMonitor(test.monitor.sdamMonitor) if testClientOpts.HeartbeatInterval == nil { // If one isn't specified in the test, use a low heartbeat frequency so the Client will quickly recover when // using failpoints that cause SDAM state changes. testClientOpts.SetHeartbeatInterval(defaultHeartbeatInterval) } mt.ResetClient(testClientOpts) // Record the underlying topology for the test's Client. test.testTopology = getTopologyFromClient(mt.Client) // Create the GridFS bucket and sessions after resetting the client so it will be created with a connected // client. createBucket(mt, testFile, test) sess0, sess1 := setupSessions(mt, test) if sess0 != nil { defer func() { sess0.EndSession(context.Background()) sess1.EndSession(context.Background()) }() } // run operations mt.ClearEvents() for idx, op := range test.Operations { err := runOperation(mt, test, op, sess0, sess1) assert.Nil(mt, err, "error running operation %q at index %d: %v", op.Name, idx, err) } // Needs to be done here (in spite of defer) because some tests // require end session to be called before we check expectation sess0.EndSession(context.Background()) sess1.EndSession(context.Background()) mt.ClearFailPoints() checkExpectations(mt, test.Expectations, sess0.ID(), sess1.ID()) if test.Outcome != nil { verifyTestOutcome(mt, test.Outcome.Collection) } }) } func createBucket(mt mtest.T, testFile testFile, testCase testCase) { if testFile.BucketName == "" { return } bucketOpts := options.GridFSBucket() if testFile.BucketName != "" { bucketOpts.SetName(testFile.BucketName) } chunkSize := testCase.chunkSize if chunkSize == 0 { chunkSize = gridfs.DefaultChunkSize } bucketOpts.SetChunkSizeBytes(chunkSize) var err error testCase.bucket, err = gridfs.NewBucket(mt.DB, bucketOpts) assert.Nil(mt, err, "NewBucket error: %v", err) } func runOperation(mt mtest.T, testCase testCase, op operation, sess0, sess1 mongo.Session) error { if op.Name == "count" { mt.Skip("count has been deprecated") } var sess mongo.Session if sessVal, err := op.Arguments.LookupErr("session"); err == nil { sessStr := sessVal.StringValue() switch sessStr { case "session0": sess = sess0 case "session1": sess = sess1 default: return fmt.Errorf("unrecognized session identifier: %v", sessStr) } } if op.Object == "testRunner" { return executeTestRunnerOperation(mt, testCase, op, sess) } if op.DatabaseOptions != nil { mt.CloneDatabase(createDatabaseOptions(mt, op.DatabaseOptions)) } if op.CollectionOptions != nil { mt.CloneCollection(createCollectionOptions(mt, op.CollectionOptions)) } // execute the command on the given object var err error switch op.Object { case "session0": err = executeSessionOperation(mt, op, sess0) case "session1": err = executeSessionOperation(mt, op, sess1) case "", "collection": // object defaults to "collection" if not specified err = executeCollectionOperation(mt, op, sess) case "database": err = executeDatabaseOperation(mt, op, sess) case "gridfsbucket": err = executeGridFSOperation(mt, testCase.bucket, op) case "client": err = executeClientOperation(mt, op, sess) default: return fmt.Errorf("unrecognized operation object: %v", op.Object) } op.opError = errorFromResult(mt, op.Result) // Some tests (e.g. crud/v2) only specify that an error should occur via the op.Error field but do not specify // which error via the op.Result field. In this case, pass in an empty non-nil operationError so verifyError will // make the right assertions. if op.Error && op.Result == nil { op.opError = &operationError{} } return verifyError(op.opError, err) } func executeGridFSOperation(mt mtest.T, bucket gridfs.Bucket, op operation) error { // no results for GridFS operations assert.Nil(mt, op.Result, "unexpected result for GridFS operation") switch op.Name { case "download": _, err := executeGridFSDownload(mt, bucket, op.Arguments) return err case "download_by_name": _, err := executeGridFSDownloadByName(mt, bucket, op.Arguments) return err default: mt.Fatalf("unrecognized gridfs operation: %v", op.Name) } return nil } func executeTestRunnerOperation(mt mtest.T, testCase testCase, op operation, sess mongo.Session) error { var clientSession session.Client if sess != nil { xsess, ok := sess.(mongo.XSession) if !ok { return fmt.Errorf("expected session type %T to implement mongo.XSession", sess) } clientSession = xsess.ClientSession() } switch op.Name { case "targetedFailPoint": fpDoc := op.Arguments.Lookup("failPoint") var fp mtest.FailPoint if err := bson.Unmarshal(fpDoc.Document(), &fp); err != nil { return fmt.Errorf("Unmarshal error: %w", err) } if clientSession == nil { return errors.New("expected valid session, got nil") } targetHost := clientSession.PinnedServer.Addr.String() opts := options.Client().ApplyURI(mtest.ClusterURI()).SetHosts([]string{targetHost}) integtest.AddTestServerAPIVersion(opts) client, err := mongo.Connect(context.Background(), opts) if err != nil { return fmt.Errorf("Connect error for targeted client: %w", err) } defer func() { _ = client.Disconnect(context.Background()) }() if err = client.Database("admin").RunCommand(context.Background(), fp).Err(); err != nil { return fmt.Errorf("error setting targeted fail point: %w", err) } mt.TrackFailPoint(fp.ConfigureFailPoint) case "configureFailPoint": fp, err := op.Arguments.LookupErr("failPoint") if err != nil { return fmt.Errorf("unable to find 'failPoint' in arguments: %w", err) } mt.SetFailPointFromDocument(fp.Document()) case "assertSessionTransactionState": stateVal, err := op.Arguments.LookupErr("state") if err != nil { return fmt.Errorf("unable to find 'state' in arguments: %w", err) } expectedState, ok := stateVal.StringValueOK() if !ok { return errors.New("expected 'state' argument to be string") } if clientSession == nil { return errors.New("expected valid session, got nil") } actualState := clientSession.TransactionState.String() // actualState should match expectedState, but "in progress" is the same as // "in_progress". stateMatch := actualState == expectedState \|\| actualState == "in progress" && expectedState == "in_progress" if !stateMatch { return fmt.Errorf("expected transaction state %v, got %v", expectedState, actualState) } case "assertSessionPinned": if clientSession == nil { return errors.New("expected valid session, got nil") } if clientSession.PinnedServer == nil { return errors.New("expected pinned server, got nil") } case "assertSessionUnpinned": if clientSession == nil { return errors.New("expected valid session, got nil") } // We don't use a combined helper for assertSessionPinned and assertSessionUnpinned because the unpinned // case provides the pinned server address in the error msg for debugging. if clientSession.PinnedServer != nil { return fmt.Errorf("expected pinned server to be nil but got %q", clientSession.PinnedServer.Addr) } case "assertSameLsidOnLastTwoCommands": first, second := lastTwoIDs(mt) if !first.Equal(second) { return fmt.Errorf("expected last two lsids to be equal but got %v and %v", first, second) } case "assertDifferentLsidOnLastTwoCommands": first, second := lastTwoIDs(mt) if first.Equal(second) { return fmt.Errorf("expected last two lsids to be not equal but both were %v", first) } case "assertCollectionExists": return verifyCollectionState(op, true) case "assertCollectionNotExists": return verifyCollectionState(op, false) case "assertIndexExists": return verifyIndexState(op, true) case "assertIndexNotExists": return verifyIndexState(op, false) case "wait": time.Sleep(convertValueToMilliseconds(mt, op.Arguments.Lookup("ms"))) case "waitForEvent": waitForEvent(mt, testCase, op) case "assertEventCount": assertEventCount(mt, testCase, op) case "recordPrimary": recordPrimary(mt, testCase) case "runAdminCommand": executeAdminCommand(mt, op) case "waitForPrimaryChange": waitForPrimaryChange(mt, testCase, op) case "startThread": startThread(mt, testCase, op) case "runOnThread": runOnThread(mt, testCase, op) case "waitForThread": waitForThread(mt, testCase, op) default: return fmt.Errorf("unrecognized testRunner operation %v", op.Name) } return nil } func verifyIndexState(op operation, shouldExist bool) error { db := op.Arguments.Lookup("database").StringValue() coll := op.Arguments.Lookup("collection").StringValue() index := op.Arguments.Lookup("index").StringValue() exists, err := indexExists(db, coll, index) if err != nil { return err } if exists != shouldExist { return fmt.Errorf("index state mismatch for index %s in namespace %s.%s; should exist: %v, exists: %v", index, db, coll, shouldExist, exists) } return nil } func indexExists(dbName, collName, indexName string) (bool, error) { // Use global client because listIndexes cannot be executed inside a transaction. iv := mtest.GlobalClient().Database(dbName).Collection(collName).Indexes() cursor, err := iv.List(context.Background()) if err != nil { return false, fmt.Errorf("IndexView.List error: %w", err) } defer cursor.Close(context.Background()) for cursor.Next(context.Background()) { if cursor.Current.Lookup("name").StringValue() == indexName { return true, nil } } return false, cursor.Err() } func verifyCollectionState(op operation, shouldExist bool) error { db := op.Arguments.Lookup("database").StringValue() coll := op.Arguments.Lookup("collection").StringValue() exists, err := collectionExists(db, coll) if err != nil { return err } if exists != shouldExist { return fmt.Errorf("collection state mismatch for %s.%s; should exist %v, exists: %v", db, coll, shouldExist, exists) } return nil } func collectionExists(dbName, collName string) (bool, error) { filter := bson.D{ {"name", collName}, } // Use global client because listCollections cannot be executed inside a transaction. collections, err := mtest.GlobalClient().Database(dbName).ListCollectionNames(context.Background(), filter) if err != nil { return false, fmt.Errorf("ListCollectionNames error: %w", err) } return len(collections) > 0, nil } func lastTwoIDs(mt mtest.T) (bson.RawValue, bson.RawValue) { events := mt.GetAllStartedEvents() lastTwoEvents := events[len(events)-2:] first := lastTwoEvents[0].Command.Lookup("lsid") second := lastTwoEvents[1].Command.Lookup("lsid") return first, second } func executeSessionOperation(mt mtest.T, op operation, sess mongo.Session) error { switch op.Name { case "startTransaction": var txnOpts options.TransactionOptions if opts, err := op.Arguments.LookupErr("options"); err == nil { txnOpts = createTransactionOptions(mt, opts.Document()) } return sess.StartTransaction(txnOpts) case "commitTransaction": return sess.CommitTransaction(context.Background()) case "abortTransaction": return sess.AbortTransaction(context.Background()) case "withTransaction": return executeWithTransaction(mt, sess, op.Arguments) default: return fmt.Errorf("unrecognized session operation: %v", op.Name) } } func executeCollectionOperation(mt mtest.T, op operation, sess mongo.Session) error { switch op.Name { case "countDocuments": // no results to verify with count res, err := executeCountDocuments(mt, sess, op.Arguments) if op.opError == nil && err == nil { verifyCountResult(mt, res, op.Result) } return err case "distinct": res, err := executeDistinct(mt, sess, op.Arguments) if op.opError == nil && err == nil { verifyDistinctResult(mt, res, op.Result) } return err case "insertOne": res, err := executeInsertOne(mt, sess, op.Arguments) if op.opError == nil && err == nil { verifyInsertOneResult(mt, res, op.Result) } return err case "insertMany": res, err := executeInsertMany(mt, sess, op.Arguments) if op.opError == nil && err == nil { verifyInsertManyResult(mt, res, op.Result) } return err case "find": cursor, err := executeFind(mt, sess, op.Arguments) if op.opError == nil && err == nil { verifyCursorResult(mt, cursor, op.Result) _ = cursor.Close(context.Background()) } return err case "findOneAndDelete": res := executeFindOneAndDelete(mt, sess, op.Arguments) if op.opError == nil && res.Err() == nil { verifySingleResult(mt, res, op.Result) } return res.Err() case "findOneAndUpdate": res := executeFindOneAndUpdate(mt, sess, op.Arguments) if op.opError == nil && res.Err() == nil { verifySingleResult(mt, res, op.Result) } return res.Err() case "findOneAndReplace": res := executeFindOneAndReplace(mt, sess, op.Arguments) if op.opError == nil && res.Err() == nil { verifySingleResult(mt, res, op.Result) } return res.Err() case "deleteOne": res, err := executeDeleteOne(mt, sess, op.Arguments) if op.opError == nil && err == nil { verifyDeleteResult(mt, res, op.Result) } return err case "deleteMany": res, err := executeDeleteMany(mt, sess, op.Arguments) if op.opError == nil && err == nil { verifyDeleteResult(mt, res, op.Result) } return err case "updateOne": res, err := executeUpdateOne(mt, sess, op.Arguments) if op.opError == nil && err == nil { verifyUpdateResult(mt, res, op.Result) } return err case "updateMany": res, err := executeUpdateMany(mt, sess, op.Arguments) if op.opError == nil && err == nil { verifyUpdateResult(mt, res, op.Result) } return err case "replaceOne": res, err := executeReplaceOne(mt, sess, op.Arguments) if op.opError == nil && err == nil { verifyUpdateResult(mt, res, op.Result) } return err case "aggregate": cursor, err := executeAggregate(mt, mt.Coll, sess, op.Arguments) if op.opError == nil && err == nil { verifyCursorResult(mt, cursor, op.Result) _ = cursor.Close(context.Background()) } return err case "bulkWrite": res, err := executeBulkWrite(mt, sess, op.Arguments) if op.opError == nil && err == nil { verifyBulkWriteResult(mt, res, op.Result) } return err case "estimatedDocumentCount": res, err := executeEstimatedDocumentCount(mt, sess, op.Arguments) if op.opError == nil && err == nil { verifyCountResult(mt, res, op.Result) } return err case "findOne": res := executeFindOne(mt, sess, op.Arguments) if op.opError == nil && res.Err() == nil { verifySingleResult(mt, res, op.Result) } return res.Err() case "listIndexes": cursor, err := executeListIndexes(mt, sess, op.Arguments) if op.opError == nil && err == nil { verifyCursorResult(mt, cursor, op.Result) _ = cursor.Close(context.Background()) } return err case "watch": stream, err := executeWatch(mt, mt.Coll, sess, op.Arguments) if op.opError == nil && err == nil { assert.Nil(mt, op.Result, "unexpected result for watch: %v", op.Result) _ = stream.Close(context.Background()) } return err case "createIndex": indexName, err := executeCreateIndex(mt, sess, op.Arguments) if op.opError == nil && err == nil { assert.Nil(mt, op.Result, "unexpected result for createIndex: %v", op.Result) assert.True(mt, len(indexName) > 0, "expected valid index name, got empty string") assert.True(mt, len(indexName) > 0, "created index has empty name") } return err case "dropIndex": res, err := executeDropIndex(mt, sess, op.Arguments) if op.opError == nil && err == nil { assert.Nil(mt, op.Result, "unexpected result for dropIndex: %v", op.Result) assert.NotNil(mt, res, "expected result from dropIndex operation, got nil") } return err case "listIndexNames", "mapReduce": mt.Skipf("operation %v not implemented", op.Name) default: mt.Fatalf("unrecognized collection operation: %v", op.Name) } return nil } func executeDatabaseOperation(mt mtest.T, op operation, sess mongo.Session) error { switch op.Name { case "runCommand": res := executeRunCommand(mt, sess, op.Arguments) if op.opError == nil && res.Err() == nil { verifySingleResult(mt, res, op.Result) } return res.Err() case "aggregate": cursor, err := executeAggregate(mt, mt.DB, sess, op.Arguments) if op.opError == nil && err == nil { verifyCursorResult(mt, cursor, op.Result) _ = cursor.Close(context.Background()) } return err case "listCollections": cursor, err := executeListCollections(mt, sess, op.Arguments) if op.opError == nil && err == nil { assert.Nil(mt, op.Result, "unexpected result for listCollections: %v", op.Result) _ = cursor.Close(context.Background()) } return err case "listCollectionNames": _, err := executeListCollectionNames(mt, sess, op.Arguments) if op.opError == nil && err == nil { assert.Nil(mt, op.Result, "unexpected result for listCollectionNames: %v", op.Result) } return err case "watch": stream, err := executeWatch(mt, mt.DB, sess, op.Arguments) if op.opError == nil && err == nil { assert.Nil(mt, op.Result, "unexpected result for watch: %v", op.Result) _ = stream.Close(context.Background()) } return err case "dropCollection": err := executeDropCollection(mt, sess, op.Arguments) if op.opError == nil && err == nil { assert.Nil(mt, op.Result, "unexpected result for dropCollection: %v", op.Result) } return err case "createCollection": err := executeCreateCollection(mt, sess, op.Arguments) if op.opError == nil && err == nil { assert.Nil(mt, op.Result, "unexpected result for createCollection: %v", op.Result) } return err case "listCollectionObjects": mt.Skipf("operation %v not implemented", op.Name) default: mt.Fatalf("unrecognized database operation: %v", op.Name) } return nil } func executeClientOperation(mt mtest.T, op operation, sess mongo.Session) error { switch op.Name { case "listDatabaseNames": _, err := executeListDatabaseNames(mt, sess, op.Arguments) if op.opError == nil && err == nil { assert.Nil(mt, op.Result, "unexpected result for countDocuments: %v", op.Result) } return err case "listDatabases": res, err := executeListDatabases(mt, sess, op.Arguments) if op.opError == nil && err == nil { verifyListDatabasesResult(mt, res, op.Result) } return err case "watch": stream, err := executeWatch(mt, mt.Client, sess, op.Arguments) if op.opError == nil && err == nil { assert.Nil(mt, op.Result, "unexpected result for watch: %v", op.Result) _ = stream.Close(context.Background()) } return err case "listDatabaseObjects": mt.Skipf("operation %v not implemented", op.Name) default: mt.Fatalf("unrecognized client operation: %v", op.Name) } return nil } func setupSessions(mt mtest.T, test testCase) (mongo.Session, mongo.Session) { mt.Helper() var sess0Opts, sess1Opts options.SessionOptions if opts, err := test.SessionOptions.LookupErr("session0"); err == nil { sess0Opts = createSessionOptions(mt, opts.Document()) } if opts, err := test.SessionOptions.LookupErr("session1"); err == nil { sess1Opts = createSessionOptions(mt, opts.Document()) } sess0, err := mt.Client.StartSession(sess0Opts) assert.Nil(mt, err, "error creating session0: %v", err) sess1, err := mt.Client.StartSession(sess1Opts) assert.Nil(mt, err, "error creating session1: %v", err) return sess0, sess1 } func insertDocuments(mt mtest.T, coll mongo.Collection, rawDocs []bson.Raw) { mt.Helper() docsToInsert := bsonutil.RawToInterfaces(rawDocs...) if len(docsToInsert) == 0 { return } _, err := coll.InsertMany(context.Background(), docsToInsert) assert.Nil(mt, err, "InsertMany error for collection %v: %v", coll.Name(), err) } // load initial data into appropriate collections and set chunkSize for the test case if necessary func setupTest(mt mtest.T, testFile testFile, testCase testCase) { mt.Helper() // key vault data if len(testFile.KeyVaultData) > 0 { // Drop the key vault collection in case it exists from a prior test run. err := mt.Client.Database("keyvault").Collection("datakeys").Drop(context.Background()) assert.Nil(mt, err, "error dropping key vault collection") keyVaultColl := mt.CreateCollection(mtest.Collection{ Name: "datakeys", DB: "keyvault", }, false) insertDocuments(mt, keyVaultColl, testFile.KeyVaultData) } // regular documents if testFile.Data.Documents != nil { insertDocuments(mt, mt.Coll, testFile.Data.Documents) return } // GridFS data gfsData := testFile.Data.GridFSData if gfsData.Chunks != nil { chunks := mt.CreateCollection(mtest.Collection{ Name: gridFSChunks, }, false) insertDocuments(mt, chunks, gfsData.Chunks) } if gfsData.Files != nil { files := mt.CreateCollection(mtest.Collection{ Name: gridFSFiles, }, false) insertDocuments(mt, files, gfsData.Files) csVal, err := gfsData.Files[0].LookupErr("chunkSize") if err == nil { testCase.chunkSize = csVal.Int32() } } } func verifyTestOutcome(mt mtest.T, outcomeColl outcomeCollection) { // Outcome needs to be verified using the global client instead of the test client because certain client // configurations will cause outcome checking to fail. For example, a client configured with auto encryption // will decrypt results, causing comparisons to fail. collName := mt.Coll.Name() if outcomeColl.Name != "" { collName = outcomeColl.Name } coll := mtest.GlobalClient().Database(mt.DB.Name()).Collection(collName, checkOutcomeOpts) findOpts := options.Find(). SetSort(bson.M{"_id": 1}) cursor, err := coll.Find(context.Background(), bson.D{}, findOpts) assert.Nil(mt, err, "Find error: %v", err) verifyCursorResult(mt, cursor, outcomeColl.Data) } func getTopologyFromClient(client mongo.Client) topology.Topology { clientElem := reflect.ValueOf(client).Elem() deploymentField := clientElem.FieldByName("deployment") deploymentField = reflect.NewAt(deploymentField.Type(), unsafe.Pointer(deploymentField.UnsafeAddr())).Elem() return deploymentField.Interface().(*topology.Topology) } // getCryptSharedLibExtraOptions returns an AutoEncryption extra options map with crypt_shared // library path information if the CRYPT_SHARED_LIB_PATH environment variable is set. func getCryptSharedLibExtraOptions() map[string]interface{} { path := os.Getenv("CRYPT_SHARED_LIB_PATH") if path == "" { return nil } return map[string]interface{}{ "cryptSharedLibRequired": true, "cryptSharedLibPath": path, } }	33.12 KB	2025-05-25 12:27

Edit File:

Terminal