GODRIVER-2520 Fix merge conflicts

benchmark/operation_test.go

@@ -32,15 +32,10 @@ func BenchmarkClientWrite(b *testing.B) {
 	}
 	for _, bm := range benchmarks {
 		b.Run(bm.name, func(b *testing.B) {
-			client, err := mongo.NewClient(bm.opt)
+			client, err := mongo.Connect(context.Background(), bm.opt)
 			if err != nil {
 				b.Fatalf("error creating client: %v", err)
 			}
-			ctx := context.Background()
-			err = client.Connect(ctx)
-			if err != nil {
-				b.Fatalf("error connecting: %v", err)
-			}
 			defer func() { _ = client.Disconnect(context.Background()) }()
 			coll := client.Database("test").Collection("test")
 			_, err = coll.DeleteMany(context.Background(), bson.D{})
@@ -76,15 +71,10 @@ func BenchmarkClientBulkWrite(b *testing.B) {
 	}
 	for _, bm := range benchmarks {
 		b.Run(bm.name, func(b *testing.B) {
-			client, err := mongo.NewClient(bm.opt)
+			client, err := mongo.Connect(context.Background(), bm.opt)
 			if err != nil {
 				b.Fatalf("error creating client: %v", err)
 			}
-			ctx := context.Background()
-			err = client.Connect(ctx)
-			if err != nil {
-				b.Fatalf("error connecting: %v", err)
-			}
 			defer func() { _ = client.Disconnect(context.Background()) }()
 			coll := client.Database("test").Collection("test")
 			_, err = coll.DeleteMany(context.Background(), bson.D{})
@@ -125,15 +115,10 @@ func BenchmarkClientRead(b *testing.B) {
 	}
 	for _, bm := range benchmarks {
 		b.Run(bm.name, func(b *testing.B) {
-			client, err := mongo.NewClient(bm.opt)
+			client, err := mongo.Connect(context.Background(), bm.opt)
 			if err != nil {
 				b.Fatalf("error creating client: %v", err)
 			}
-			ctx := context.Background()
-			err = client.Connect(ctx)
-			if err != nil {
-				b.Fatalf("error connecting: %v", err)
-			}
 			defer func() { _ = client.Disconnect(context.Background()) }()
 			coll := client.Database("test").Collection("test")
 			_, err = coll.DeleteMany(context.Background(), bson.D{})

benchmark/single.go

@@ -29,13 +29,10 @@ func getClientDB(ctx context.Context) (*mongo.Database, error) {
 	if err != nil {
 		return nil, err
 	}
-	client, err := mongo.NewClient(options.Client().ApplyURI(cs.String()))
+	client, err := mongo.Connect(ctx, options.Client().ApplyURI(cs.String()))
 	if err != nil {
 		return nil, err
 	}
-	if err = client.Connect(ctx); err != nil {
-		return nil, err
-	}
 
 	db := client.Database(integtest.GetDBName(cs))
 	return db, nil

event/monitoring.go

@@ -23,12 +23,6 @@ type CommandStartedEvent struct {
 	CommandName  string
 	RequestID    int64
 	ConnectionID string
-	// ServerConnectionID contains the connection ID from the server of the operation. If the server does not return
-	// this value (e.g. on MDB < 4.2), it is unset. If the server connection ID would cause an int32 overflow, then
-	// then this field will be nil.
-	//
-	// Deprecated: Use ServerConnectionID64.
-	ServerConnectionID *int32
 	// ServerConnectionID64 contains the connection ID from the server of the operation. If the server does not
 	// return this value (e.g. on MDB < 4.2), it is unset.
 	ServerConnectionID64 *int64
@@ -39,19 +33,11 @@ type CommandStartedEvent struct {
 
 // CommandFinishedEvent represents a generic command finishing.
 type CommandFinishedEvent struct {
-	// Deprecated: Use Duration instead.
-	DurationNanos int64
-	Duration      time.Duration
-	CommandName   string
-	DatabaseName  string
-	RequestID     int64
-	ConnectionID  string
-	// ServerConnectionID contains the connection ID from the server of the operation. If the server does not return
-	// this value (e.g. on MDB < 4.2), it is unset.If the server connection ID would cause an int32 overflow, then
-	// this field will be nil.
-	//
-	// Deprecated: Use ServerConnectionID64.
-	ServerConnectionID *int32
+	Duration     time.Duration
+	CommandName  string
+	DatabaseName string
+	RequestID    int64
+	ConnectionID string
 	// ServerConnectionID64 contains the connection ID from the server of the operation. If the server does not
 	// return this value (e.g. on MDB < 4.2), it is unset.
 	ServerConnectionID64 *int64
@@ -174,22 +160,18 @@ type ServerHeartbeatStartedEvent struct {
 
 // ServerHeartbeatSucceededEvent is an event generated when the heartbeat succeeds.
 type ServerHeartbeatSucceededEvent struct {
-	// Deprecated: Use Duration instead.
-	DurationNanos int64
-	Duration      time.Duration
-	Reply         description.Server
-	ConnectionID  string // The address this heartbeat was sent to with a unique identifier
-	Awaited       bool   // If this heartbeat was awaitable
+	Duration     time.Duration
+	Reply        description.Server
+	ConnectionID string // The address this heartbeat was sent to with a unique identifier
+	Awaited      bool   // If this heartbeat was awaitable
 }
 
 // ServerHeartbeatFailedEvent is an event generated when the heartbeat fails.
 type ServerHeartbeatFailedEvent struct {
-	// Deprecated: Use Duration instead.
-	DurationNanos int64
-	Duration      time.Duration
-	Failure       error
-	ConnectionID  string // The address this heartbeat was sent to with a unique identifier
-	Awaited       bool   // If this heartbeat was awaitable
+	Duration     time.Duration
+	Failure      error
+	ConnectionID string // The address this heartbeat was sent to with a unique identifier
+	Awaited      bool   // If this heartbeat was awaitable
 }
 
 // ServerMonitor represents a monitor that is triggered for different server events. The client

examples/documentation_examples/examples.go

@@ -1763,7 +1763,7 @@ func UpdateEmployeeInfo(ctx context.Context, client *mongo.Client) error {
 	return client.UseSession(ctx, func(sctx mongo.SessionContext) error {
 		err := sctx.StartTransaction(options.Transaction().
 			SetReadConcern(readconcern.Snapshot()).
-			SetWriteConcern(writeconcern.New(writeconcern.WMajority())),
+			SetWriteConcern(writeconcern.Majority()),
 		)
 		if err != nil {
 			return err
@@ -1921,7 +1921,7 @@ func TransactionsExamples(ctx context.Context, client *mongo.Client) error {
 
 		err := sctx.StartTransaction(options.Transaction().
 			SetReadConcern(readconcern.Snapshot()).
-			SetWriteConcern(writeconcern.New(writeconcern.WMajority())),
+			SetWriteConcern(writeconcern.Majority()),
 		)
 		if err != nil {
 			return err
@@ -1971,7 +1971,8 @@ func WithTransactionExample(ctx context.Context) error {
 	defer func() { _ = client.Disconnect(ctx) }()
 
 	// Prereq: Create collections.
-	wcMajority := writeconcern.New(writeconcern.WMajority(), writeconcern.WTimeout(1*time.Second))
+	wcMajority := writeconcern.Majority()
+	wcMajority.WTimeout = 1 * time.Second
 	wcMajorityCollectionOpts := options.Collection().SetWriteConcern(wcMajority)
 	fooColl := client.Database("mydb1").Collection("foo", wcMajorityCollectionOpts)
 	barColl := client.Database("mydb1").Collection("bar", wcMajorityCollectionOpts)
@@ -2550,9 +2551,11 @@ func CausalConsistencyExamples(client *mongo.Client) error {
 
 	// Start Causal Consistency Example 1
 
+	rc := readconcern.Majority()
+	wc := writeconcern.Majority()
+	wc.WTimeout = 1000
 	// Use a causally-consistent session to run some operations
-	opts := options.Session().SetDefaultReadConcern(readconcern.Majority()).SetDefaultWriteConcern(
-		writeconcern.New(writeconcern.WMajority(), writeconcern.WTimeout(1000)))
+	opts := options.Session().SetDefaultReadConcern(rc).SetDefaultWriteConcern(wc)
 	session1, err := client.StartSession(opts)
 	if err != nil {
 		return err
@@ -2584,9 +2587,8 @@ func CausalConsistencyExamples(client *mongo.Client) error {
 	// Start Causal Consistency Example 2
 
 	// Make a new session that is causally consistent with session1 so session2 reads what session1 writes
-	opts = options.Session().SetDefaultReadPreference(readpref.Secondary()).SetDefaultReadConcern(
-		readconcern.Majority()).SetDefaultWriteConcern(writeconcern.New(writeconcern.WMajority(),
-		writeconcern.WTimeout(1000)))
+	opts = options.Session().SetDefaultReadPreference(readpref.Secondary()).
+		SetDefaultReadConcern(rc).SetDefaultWriteConcern(wc)
 	session2, err := client.StartSession(opts)
 	if err != nil {
 		return err

mongo/change_stream.go

@@ -101,6 +101,55 @@ type changeStreamConfig struct {
 	crypt          driver.Crypt
 }
 
+// mergeChangeStreamOptions combines the given ChangeStreamOptions instances into a single ChangeStreamOptions in a
+// last-property-wins fashion.
+func mergeChangeStreamOptions(opts ...*options.ChangeStreamOptions) *options.ChangeStreamOptions {
+	csOpts := options.ChangeStream()
+	for _, cso := range opts {
+		if cso == nil {
+			continue
+		}
+		if cso.BatchSize != nil {
+			csOpts.BatchSize = cso.BatchSize
+		}
+		if cso.Collation != nil {
+			csOpts.Collation = cso.Collation
+		}
+		if cso.Comment != nil {
+			csOpts.Comment = cso.Comment
+		}
+		if cso.FullDocument != nil {
+			csOpts.FullDocument = cso.FullDocument
+		}
+		if cso.FullDocumentBeforeChange != nil {
+			csOpts.FullDocumentBeforeChange = cso.FullDocumentBeforeChange
+		}
+		if cso.MaxAwaitTime != nil {
+			csOpts.MaxAwaitTime = cso.MaxAwaitTime
+		}
+		if cso.ResumeAfter != nil {
+			csOpts.ResumeAfter = cso.ResumeAfter
+		}
+		if cso.ShowExpandedEvents != nil {
+			csOpts.ShowExpandedEvents = cso.ShowExpandedEvents
+		}
+		if cso.StartAtOperationTime != nil {
+			csOpts.StartAtOperationTime = cso.StartAtOperationTime
+		}
+		if cso.StartAfter != nil {
+			csOpts.StartAfter = cso.StartAfter
+		}
+		if cso.Custom != nil {
+			csOpts.Custom = cso.Custom
+		}
+		if cso.CustomPipeline != nil {
+			csOpts.CustomPipeline = cso.CustomPipeline
+		}
+	}
+
+	return csOpts
+}
+
 func newChangeStream(ctx context.Context, config changeStreamConfig, pipeline interface{},
 	opts ...*options.ChangeStreamOptions) (*ChangeStream, error) {
 	if ctx == nil {
@@ -116,7 +165,7 @@ func newChangeStream(ctx context.Context, config changeStreamConfig, pipeline in
 		bsonOpts:   config.bsonOpts,
 		registry:   config.registry,
 		streamType: config.streamType,
-		options:    options.MergeChangeStreamOptions(opts...),
+		options:    mergeChangeStreamOptions(opts...),
 		selector: description.CompositeSelector([]description.ServerSelector{
 			description.ReadPrefSelector(config.readPreference),
 			description.LatencySelector(config.client.localThreshold),

mongo/change_stream_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"go.mongodb.org/mongo-driver/internal/assert"
+	"go.mongodb.org/mongo-driver/mongo/options"
 )
 
 func TestChangeStream(t *testing.T) {
@@ -27,3 +28,65 @@ func TestChangeStream(t *testing.T) {
 		assert.Nil(t, err, "Close error: %v", err)
 	})
 }
+
+func TestMergeChangeStreamOptions(t *testing.T) {
+	t.Parallel()
+
+	fullDocumentP := func(x options.FullDocument) *options.FullDocument { return &x }
+	int32P := func(x int32) *int32 { return &x }
+
+	testCases := []struct {
+		description string
+		input       []*options.ChangeStreamOptions
+		want        *options.ChangeStreamOptions
+	}{
+		{
+			description: "nil",
+			input:       nil,
+			want:        &options.ChangeStreamOptions{},
+		},
+		{
+			description: "empty",
+			input:       []*options.ChangeStreamOptions{},
+			want:        &options.ChangeStreamOptions{},
+		},
+		{
+			description: "many ChangeStreamOptions with one configuration each",
+			input: []*options.ChangeStreamOptions{
+				options.ChangeStream().SetFullDocumentBeforeChange(options.Required),
+				options.ChangeStream().SetFullDocument(options.Required),
+				options.ChangeStream().SetBatchSize(10),
+			},
+			want: &options.ChangeStreamOptions{
+				FullDocument:             fullDocumentP(options.Required),
+				FullDocumentBeforeChange: fullDocumentP(options.Required),
+				BatchSize:                int32P(10),
+			},
+		},
+		{
+			description: "single ChangeStreamOptions with many configurations",
+			input: []*options.ChangeStreamOptions{
+				options.ChangeStream().
+					SetFullDocumentBeforeChange(options.Required).
+					SetFullDocument(options.Required).
+					SetBatchSize(10),
+			},
+			want: &options.ChangeStreamOptions{
+				FullDocument:             fullDocumentP(options.Required),
+				FullDocumentBeforeChange: fullDocumentP(options.Required),
+				BatchSize:                int32P(10),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc // Capture range variable.
+
+		t.Run(tc.description, func(t *testing.T) {
+			t.Parallel()
+
+			got := mergeChangeStreamOptions(tc.input...)
+			assert.Equal(t, tc.want, got, "expected and actual ChangeStreamOptions are different")
+		})
+	}
+}