Revert mongo.Connect() changes

benchmark/operation_test.go

@@ -32,10 +32,15 @@ func BenchmarkClientWrite(b *testing.B) {
  }
  for _, bm := range benchmarks {
  b.Run(bm.name, func(b *testing.B) {
- client, err := mongo.Connect(context.Background(), bm.opt)
+ client, err := mongo.NewClient(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 client.Disconnect(context.Background())
  coll := client.Database("test").Collection("test")
  _, err = coll.DeleteMany(context.Background(), bson.D{})
@@ -71,10 +76,15 @@ func BenchmarkClientBulkWrite(b *testing.B) {
  }
  for _, bm := range benchmarks {
  b.Run(bm.name, func(b *testing.B) {
- client, err := mongo.Connect(context.Background(), bm.opt)
+ client, err := mongo.NewClient(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 client.Disconnect(context.Background())
  coll := client.Database("test").Collection("test")
  _, err = coll.DeleteMany(context.Background(), bson.D{})
@@ -115,10 +125,15 @@ func BenchmarkClientRead(b *testing.B) {
  }
  for _, bm := range benchmarks {
  b.Run(bm.name, func(b *testing.B) {
- client, err := mongo.Connect(context.Background(), bm.opt)
+ client, err := mongo.NewClient(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 client.Disconnect(context.Background())
  coll := client.Database("test").Collection("test")
  _, err = coll.DeleteMany(context.Background(), bson.D{})

benchmark/single.go

@@ -29,10 +29,13 @@ func getClientDB(ctx context.Context) (*mongo.Database, error) {
  if err != nil {
  return nil, err
  }
- client, err := mongo.Connect(ctx, options.Client().ApplyURI(cs.String()))
+ client, err := mongo.NewClient(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

mongo/client.go

@@ -81,7 +81,8 @@ type Client struct {
  encryptedFieldsMap map[string]interface{}
 }
 
-// Connect creates a new Client and then initializes it using the Connect method.
+// Connect creates a new Client and then initializes it using the Connect method. This is equivalent to calling
+// NewClient followed by Client.Connect.
 //
 // When creating an options.ClientOptions, the order the methods are called matters. Later Set*
 // methods will overwrite the values from previous Set* method invocations. This includes the
@@ -103,18 +104,18 @@ type Client struct {
 // The Client.Ping method can be used to verify that the deployment is successfully connected and the
 // Client was correctly configured.
 func Connect(ctx context.Context, opts ...*options.ClientOptions) (*Client, error) {
- c, err := newClient(opts...)
+ c, err := NewClient(opts...)
  if err != nil {
  return nil, err
  }
- err = c.connect(ctx)
+ err = c.Connect(ctx)
  if err != nil {
  return nil, err
  }
  return c, nil
 }
 
-// newClient creates a new client to connect to a deployment specified by the uri.
+// NewClient creates a new client to connect to a deployment specified by the uri.
 //
 // When creating an options.ClientOptions, the order the methods are called matters. Later Set*
 // methods will overwrite the values from previous Set* method invocations. This includes the
@@ -127,7 +128,9 @@ func Connect(ctx context.Context, opts ...*options.ClientOptions) (*Client, erro
 // option fields of previous options, there is no partial overwriting. For example, if Username is
 // set in the Auth field for the first option, and Password is set for the second but with no
 // Username, after the merge the Username field will be empty.
-func newClient(opts ...*options.ClientOptions) (*Client, error) {
+//
+// Deprecated: Use [Connect] instead.
+func NewClient(opts ...*options.ClientOptions) (*Client, error) {
  clientOpt := options.MergeClientOptions(opts...)
 
  id, err := uuid.New()
@@ -232,12 +235,14 @@ func newClient(opts ...*options.ClientOptions) (*Client, error) {
  return client, nil
 }
 
-// connect initializes the Client by starting background monitoring goroutines.
+// Connect initializes the Client by starting background monitoring goroutines.
 // If the Client was created using the NewClient function, this method must be called before a Client can be used.
 //
 // Connect starts background goroutines to monitor the state of the deployment and does not do any I/O in the main
 // goroutine. The Client.Ping method can be used to verify that the connection was created successfully.
-func (c *Client) connect(ctx context.Context) error {
+//
+// Deprecated: Use [mongo.Connect] instead.
+func (c *Client) Connect(ctx context.Context) error {
  if connector, ok := c.deployment.(driver.Connector); ok {
  err := connector.Connect()
  if err != nil {
@@ -252,19 +257,19 @@ func (c *Client) connect(ctx context.Context) error {
  }
 
  if c.internalClientFLE != nil {
- if err := c.internalClientFLE.connect(ctx); err != nil {
+ if err := c.internalClientFLE.Connect(ctx); err != nil {
  return err
  }
  }
 
  if c.keyVaultClientFLE != nil && c.keyVaultClientFLE != c.internalClientFLE && c.keyVaultClientFLE != c {
- if err := c.keyVaultClientFLE.connect(ctx); err != nil {
+ if err := c.keyVaultClientFLE.Connect(ctx); err != nil {
  return err
  }
  }
 
  if c.metadataClientFLE != nil && c.metadataClientFLE != c.internalClientFLE && c.metadataClientFLE != c {
- if err := c.metadataClientFLE.connect(ctx); err != nil {
+ if err := c.metadataClientFLE.Connect(ctx); err != nil {
  return err
  }
  }
@@ -484,7 +489,7 @@ func (c *Client) getOrCreateInternalClient(clientOpts *options.ClientOptions) (*
  internalClientOpts.AutoEncryptionOptions = nil
  internalClientOpts.SetMinPoolSize(0)
  var err error
- c.internalClientFLE, err = newClient(internalClientOpts)
+ c.internalClientFLE, err = NewClient(internalClientOpts)
  return c.internalClientFLE, err
 }
 
@@ -494,7 +499,7 @@ func (c *Client) configureKeyVaultClientFLE(clientOpts *options.ClientOptions) e
  aeOpts := clientOpts.AutoEncryptionOptions
  switch {
  case aeOpts.KeyVaultClientOptions != nil:
- c.keyVaultClientFLE, err = newClient(aeOpts.KeyVaultClientOptions)
+ c.keyVaultClientFLE, err = NewClient(aeOpts.KeyVaultClientOptions)
  case clientOpts.MaxPoolSize != nil && *clientOpts.MaxPoolSize == 0:
  c.keyVaultClientFLE = c
  default:

mongo/client_test.go

@@ -35,7 +35,7 @@ func setupClient(opts ...*options.ClientOptions) *Client {
  integtest.AddTestServerAPIVersion(clientOpts)
  opts = append(opts, clientOpts)
  }
- client, _ := newClient(opts...)
+ client, _ := NewClient(opts...)
  return client
 }
 
@@ -183,7 +183,7 @@ func TestClient(t *testing.T) {
  }
  for _, tc := range testCases {
  t.Run(tc.name, func(t *testing.T) {
- _, err := newClient(tc.opts)
+ _, err := NewClient(tc.opts)
  assert.Equal(t, tc.err, err, "expected error %v, got %v", tc.err, err)
  })
  }
@@ -227,7 +227,7 @@ func TestClient(t *testing.T) {
  }
  for _, tc := range testCases {
  t.Run(tc.name, func(t *testing.T) {
- _, err := newClient(tc.opts)
+ _, err := NewClient(tc.opts)
  assert.Equal(t, tc.err, err, "expected error %v, got %v", tc.err, err)
  })
  }
@@ -249,7 +249,7 @@ func TestClient(t *testing.T) {
  }
  for _, tc := range testCases {
  t.Run(tc.name, func(t *testing.T) {
- client, err := newClient(tc.opts)
+ client, err := NewClient(tc.opts)
  if tc.expectErr {
  assert.NotNil(t, err, "expected error, got nil")
  return
@@ -277,7 +277,7 @@ func TestClient(t *testing.T) {
  }
  for _, tc := range testCases {
  t.Run(tc.name, func(t *testing.T) {
- client, err := newClient(tc.opts)
+ client, err := NewClient(tc.opts)
  if tc.expectErr {
  assert.NotNil(t, err, "expected error, got nil")
  return
@@ -412,22 +412,22 @@ func TestClient(t *testing.T) {
 
  t.Run("success with all options", func(t *testing.T) {
  serverAPIOptions := getServerAPIOptions()
- client, err := newClient(options.Client().SetServerAPIOptions(serverAPIOptions))
+ client, err := NewClient(options.Client().SetServerAPIOptions(serverAPIOptions))
  assert.Nil(t, err, "unexpected error from NewClient: %v", err)
  convertedAPIOptions := topology.ConvertToDriverAPIOptions(serverAPIOptions)
  assert.Equal(t, convertedAPIOptions, client.serverAPI,
  "mismatch in serverAPI; expected %v, got %v", convertedAPIOptions, client.serverAPI)
  })
  t.Run("failure with unsupported version", func(t *testing.T) {
  serverAPIOptions := options.ServerAPI("badVersion")
- _, err := newClient(options.Client().SetServerAPIOptions(serverAPIOptions))
+ _, err := NewClient(options.Client().SetServerAPIOptions(serverAPIOptions))
  assert.NotNil(t, err, "expected error from NewClient, got nil")
  errmsg := `api version "badVersion" not supported; this driver version only supports API version "1"`
  assert.Equal(t, errmsg, err.Error(), "expected error %v, got %v", errmsg, err.Error())
  })
  t.Run("cannot modify options after client creation", func(t *testing.T) {
  serverAPIOptions := getServerAPIOptions()
- client, err := newClient(options.Client().SetServerAPIOptions(serverAPIOptions))
+ client, err := NewClient(options.Client().SetServerAPIOptions(serverAPIOptions))
  assert.Nil(t, err, "unexpected error from NewClient: %v", err)
 
  expectedServerAPIOptions := getServerAPIOptions()
@@ -476,7 +476,7 @@ func TestClient(t *testing.T) {
  extraOptions["__cryptSharedLibDisabledForTestOnly"] = true
  }
 
- _, err := newClient(options.Client().
+ _, err := NewClient(options.Client().
  SetAutoEncryptionOptions(options.AutoEncryption().
  SetKmsProviders(map[string]map[string]interface{}{
  "local": {"key": make([]byte, 96)},

mongo/database_test.go

@@ -97,7 +97,7 @@ func TestDatabase(t *testing.T) {
  })
  t.Run("TransientTransactionError label", func(t *testing.T) {
  client := setupClient(options.Client().ApplyURI("mongodb://nonexistent").SetServerSelectionTimeout(3 * time.Second))
- err := client.connect(bgCtx)
+ err := client.Connect(bgCtx)
  defer client.Disconnect(bgCtx)
  assert.Nil(t, err, "expected nil, got %v", err)
 

mongo/integration/client_options_test.go

@@ -24,7 +24,9 @@ func TestClientOptions_CustomDialer(t *testing.T) {
  cs := integtest.ConnString(t)
  opts := options.Client().ApplyURI(cs.String()).SetDialer(td)
  integtest.AddTestServerAPIVersion(opts)
- client, err := mongo.Connect(context.Background(), 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)

mongo/integration/client_test.go

@@ -341,7 +341,7 @@ func TestClient(t *testing.T) {
  })
  mt.RunOpts("watch", noClientOpts, func(mt *mtest.T) {
  mt.Run("disconnected", func(mt *mtest.T) {
- c, err := mongo.Connect(context.Background(), options.Client().ApplyURI(mtest.ClusterURI()))
+ 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)

mongo/integration/mtest/mongotest.go

@@ -689,13 +689,13 @@ func (t *T) createTestClient() {
  // pin to first mongos
  pinnedHostList := []string{testContext.connString.Hosts[0]}
  uriOpts := options.Client().ApplyURI(testContext.connString.Original).SetHosts(pinnedHostList)
- t.Client, err = mongo.Connect(context.Background(), uriOpts, clientOpts)
+ t.Client, err = mongo.NewClient(uriOpts, clientOpts)
  case Mock:
  // clear pool monitor to avoid configuration error
  clientOpts.PoolMonitor = nil
  t.mockDeployment = newMockDeployment()
  clientOpts.Deployment = t.mockDeployment
- t.Client, err = mongo.Connect(context.Background(), clientOpts)
+ t.Client, err = mongo.NewClient(clientOpts)
  case Proxy:
  t.proxyDialer = newProxyDialer()
  clientOpts.SetDialer(t.proxyDialer)
@@ -713,11 +713,14 @@ func (t *T) createTestClient() {
  }
 
  // Pass in uriOpts first so clientOpts wins if there are any conflicting settings.
- t.Client, err = mongo.Connect(context.Background(), uriOpts, clientOpts)
+ t.Client, err = mongo.NewClient(uriOpts, clientOpts)
  }
  if err != nil {
  t.Fatalf("error creating client: %v", err)
  }
+ if err := t.Client.Connect(context.Background()); err != nil {
+ t.Fatalf("error connecting client: %v", err)
+ }
 }
 
 func (t *T) createTestCollection() {

mongo/mongocryptd.go

@@ -74,7 +74,7 @@ func newMongocryptdClient(opts *options.AutoEncryptionOptions) (*mongocryptdClie
  }
 
  // create client
- client, err := Connect(context.Background(), options.Client().ApplyURI(uri).SetServerSelectionTimeout(defaultServerSelectionTimeout))
+ client, err := NewClient(options.Client().ApplyURI(uri).SetServerSelectionTimeout(defaultServerSelectionTimeout))
  if err != nil {
  return nil, err
  }
@@ -114,7 +114,7 @@ func (mc *mongocryptdClient) markCommand(ctx context.Context, dbName string, cmd
 
 // connect connects the underlying Client instance. This must be called before performing any mark operations.
 func (mc *mongocryptdClient) connect(ctx context.Context) error {
- return mc.client.connect(ctx)
+ return mc.client.Connect(ctx)
 }
 
 // disconnect disconnects the underlying Client instance. This should be called after all operations have completed.

x/mongo/driver/topology/topology_test.go

@@ -607,7 +607,7 @@ func TestSessionTimeout(t *testing.T) {
 
  currDesc := topo.desc.Load().(description.Topology)
  require.Nil(t, currDesc.SessionTimeoutMinutesPtr,
- "session timeout minutes mismatch. got: %d. expected: nil", *currDesc.SessionTimeoutMinutesPtr)
+ "session timeout minutes mismatch. expected: nil")
  })
 }