updates

Author: qingyang-hu

mongo/integration/mtest/mongotest.go

@@ -84,11 +84,6 @@ type WriteConcernErrorData struct {
 	ErrInfo     bson.Raw  `bson:"errInfo,omitempty"`
 }
 
-type failPoint struct {
-	name       string
-	clientOpts *options.ClientOptions
-}
-
 // T is a wrapper around testing.T.
 type T struct {
 	// connsCheckedOut is the net number of connections checked out during test execution.
@@ -108,7 +103,7 @@ type T struct {
 	createdColls      []*Collection // collections created in this test
 	proxyDialer       *proxyDialer
 	dbName, collName  string
-	failPointNames    []failPoint
+	failPointNames    []string
 	minServerVersion  string
 	maxServerVersion  string
 	validTopologies   []TopologyKind
@@ -133,9 +128,10 @@ type T struct {
 	succeeded   []*event.CommandSucceededEvent
 	failed      []*event.CommandFailedEvent
 
-	Client *mongo.Client
-	DB     *mongo.Database
-	Coll   *mongo.Collection
+	Client   *mongo.Client
+	fpClient *mongo.Client
+	DB       *mongo.Database
+	Coll     *mongo.Collection
 }
 
 func newT(wrapped *testing.T, opts ...*Options) *T {
@@ -183,7 +179,7 @@ func New(wrapped *testing.T, opts ...*Options) *T {
 	// only create a client if it needs to be shared in sub-tests
 	// otherwise, a new client will be created for each subtest
 	if t.shareClient != nil && *t.shareClient {
-		t.createTestClient()
+		t.createTestClient(true)
 	}
 
 	wrapped.Cleanup(t.cleanup)
@@ -207,6 +203,7 @@ func (t *T) cleanup() {
 	// always disconnect the client regardless of clientType because Client.Disconnect will work against
 	// all deployments
 	_ = t.Client.Disconnect(context.Background())
+	_ = t.fpClient.Disconnect(context.Background())
 }
 
 // Run creates a new T instance for a sub-test and runs the given callback. It also creates a new collection using the
@@ -236,13 +233,14 @@ func (t *T) RunOpts(name string, opts *Options, callback func(mt *T)) {
 		// only create a client if not already set
 		if sub.Client == nil {
 			if sub.createClient == nil || *sub.createClient {
-				sub.createTestClient()
+				sub.createTestClient(false)
 			}
 		}
 		// create a collection for this test
 		if sub.Client != nil {
 			sub.createTestCollection()
 		}
+		sub.fpClient = t.fpClient
 
 		// defer dropping all collections if the test is using a client
 		defer func() {
@@ -411,7 +409,7 @@ func (t *T) ResetClient(opts *options.ClientOptions) {
 	}
 
 	_ = t.Client.Disconnect(context.Background())
-	t.createTestClient()
+	t.createTestClient(false)
 	t.DB = t.Client.Database(t.dbName)
 	t.Coll = t.DB.Collection(t.collName, t.collOpts)
 
@@ -564,54 +562,42 @@ func (t *T) SetFailPoint(fp FailPoint) {
 		}
 	}
 
-	if err := SetFailPoint(fp, t.Client); err != nil {
+	if err := SetFailPoint(fp, t.fpClient); err != nil {
 		t.Fatal(err)
 	}
-	clientOpts := *t.clientOpts
-	t.failPointNames = append(t.failPointNames, failPoint{fp.ConfigureFailPoint, &clientOpts})
+	t.failPointNames = append(t.failPointNames, fp.ConfigureFailPoint)
 }
 
 // SetFailPointFromDocument sets the fail point represented by the given document for the client associated with T. This
 // method assumes that the given document is in the form {configureFailPoint: <failPointName>, ...}. Commands to create
 // the failpoint will appear in command monitoring channels. The fail point will be automatically disabled after this
 // test has run.
 func (t *T) SetFailPointFromDocument(fp bson.Raw) {
-	if err := SetRawFailPoint(fp, t.Client); err != nil {
+	if err := SetRawFailPoint(fp, t.fpClient); err != nil {
 		t.Fatal(err)
 	}
 
 	name := fp.Index(0).Value().StringValue()
-	clientOpts := *t.clientOpts
-	t.failPointNames = append(t.failPointNames, failPoint{name, &clientOpts})
+	t.failPointNames = append(t.failPointNames, name)
 }
 
 // TrackFailPoint adds the given fail point to the list of fail points to be disabled when the current test finishes.
 // This function does not create a fail point on the server.
 func (t *T) TrackFailPoint(fpName string) {
-	clientOpts := *t.clientOpts
-	t.failPointNames = append(t.failPointNames, failPoint{fpName, &clientOpts})
+	t.failPointNames = append(t.failPointNames, fpName)
 }
 
 // ClearFailPoints disables all previously set failpoints for this test.
 func (t *T) ClearFailPoints() {
+	db := t.fpClient.Database("admin")
 	for _, fp := range t.failPointNames {
-		client, err := mongo.NewClient(fp.clientOpts)
-		if err != nil {
-			t.Fatalf("error creating client: %v", err)
-		}
-		if err = client.Connect(context.Background()); err != nil {
-			t.Fatalf("error connecting client: %v", err)
-		}
-		defer func() {
-			_ = client.Disconnect(context.Background())
-		}()
 		cmd := bson.D{
-			{"configureFailPoint", fp.name},
+			{"configureFailPoint", fp},
 			{"mode", "off"},
 		}
-		err = client.Database("admin").RunCommand(context.Background(), cmd).Err()
+		err := db.RunCommand(context.Background(), cmd).Err()
 		if err != nil {
-			t.Fatalf("error clearing fail point %s: %v", fp.name, err)
+			t.Fatalf("error clearing fail point %s: %v", fp, err)
 		}
 	}
 	t.failPointNames = t.failPointNames[:0]
@@ -642,7 +628,7 @@ func sanitizeCollectionName(db string, coll string) string {
 	return coll
 }
 
-func (t *T) createTestClient() {
+func (t *T) createTestClient(createFpClient bool) {
 	clientOpts := t.clientOpts
 	if clientOpts == nil {
 		// default opts
@@ -738,6 +724,16 @@ func (t *T) createTestClient() {
 	if err := t.Client.Connect(context.Background()); err != nil {
 		t.Fatalf("error connecting client: %v", err)
 	}
+
+	if createFpClient {
+		t.fpClient, err = mongo.NewClient(t.clientOpts)
+		if err != nil {
+			t.Fatalf("error creating client: %v", err)
+		}
+		if err := t.fpClient.Connect(context.Background()); err != nil {
+			t.Fatalf("error connecting client: %v", err)
+		}
+	}
 }
 
 func (t *T) createTestCollection() {