GODRIVER-1758 add missing error conversions (#512)

Author: iwysiu

mongo/cursor.go

@@ -124,7 +124,7 @@ func (c *Cursor) next(ctx context.Context, nonBlocking bool) bool {
 		// If we don't have a next batch
 		if !c.bc.Next(ctx) {
 			// Do we have an error? If so we return false.
-			c.err = c.bc.Err()
+			c.err = replaceErrors(c.bc.Err())
 			if c.err != nil {
 				return false
 			}
@@ -176,7 +176,7 @@ func (c *Cursor) Err() error { return c.err }
 // the first call, any subsequent calls will not change the state.
 func (c *Cursor) Close(ctx context.Context) error {
 	defer c.closeImplicitSession()
-	return c.bc.Close(ctx)
+	return replaceErrors(c.bc.Close(ctx))
 }
 
 // All iterates the cursor and decodes each document into results. The results parameter must be a pointer to a slice.
@@ -219,7 +219,7 @@ func (c *Cursor) All(ctx context.Context, results interface{}) error {
 		batch = c.bc.Batch()
 	}
 
-	if err = c.bc.Err(); err != nil {
+	if err = replaceErrors(c.bc.Err()); err != nil {
 		return err
 	}
 

mongo/database.go

@@ -192,8 +192,10 @@ func (db *Database) RunCommand(ctx context.Context, runCommand interface{}, opts
 	}
 
 	err = op.Execute(ctx)
+	// RunCommand can be used to run a write, thus execute may return a write error
+	_, convErr := processWriteError(err)
 	return &SingleResult{
-		err: replaceErrors(err),
+		err: convErr,
 		rdr: bson.Raw(op.Result()),
 		reg: db.registry,
 	}

mongo/integration/cursor_test.go

@@ -165,6 +165,58 @@ func TestCursor(t *testing.T) {
 			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(mtest.Background, bson.D{}, options.Find().SetBatchSize(2))
+			assert.Nil(mt, err, "Find error: %v", err)
+			defer cursor.Close(mtest.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.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(mtest.Background, bson.D{}, options.Find().SetBatchSize(2))
+			assert.Nil(mt, err, "Find error: %v", err)
+
+			err = cursor.Close(mtest.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)
+		})
+	})
 }
 
 type tryNextCursor interface {
@@ -198,12 +250,13 @@ func verifyOneGetmoreSent(mt *mtest.T, cursor tryNextCursor) {
 
 // should be called in a test run with a mock deployment
 func tryNextGetmoreError(mt *mtest.T, cursor tryNextCursor) {
-	getMoreRes := mtest.CreateCommandErrorResponse(mtest.CommandError{
+	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
@@ -215,6 +268,14 @@ func tryNextGetmoreError(mt *mtest.T, cursor tryNextCursor) {
 
 	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) {

mongo/integration/database_test.go

@@ -88,6 +88,35 @@ func TestDatabase(t *testing.T) {
 			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(mtest.Background, cmd).DecodeBytes()
+
+			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, "expeced error code 100, got %v", writeExcept.WriteConcernError.Code)
+		})
 	})
 
 	dropOpts := mtest.NewOptions().DatabaseName("dropDb")

mongo/integration/mtest/deployment_helpers.go

@@ -72,7 +72,7 @@ func CreateCommandErrorResponse(ce CommandError) bson.D {
 		for _, label := range ce.Labels {
 			labelsArr = append(labelsArr, label)
 		}
-		res = append(res, bson.E{Key: "labels", Value: labelsArr})
+		res = append(res, bson.E{Key: "errorLabels", Value: labelsArr})
 	}
 	return res
 }