GODRIVER-1807 Add UpdateByID (#553)

Author: iwysiu

mongo/collection.go

@@ -581,6 +581,27 @@ func (coll *Collection) updateOrReplace(ctx context.Context, filter bsoncore.Doc
 	return res, err
 }
 
+// UpdateByID executes an update command to update the document whose _id value matches the provided ID in the collection.
+// This is equivalent to running UpdateOne(ctx, bson.D{{"_id", id}}, update, opts...).
+//
+// The id parameter is the _id of the document to be updated. It cannot be nil. If the ID does not match any documents,
+// the operation will succeed and an UpdateResult with a MatchedCount of 0 will be returned.
+//
+// The update parameter must be a document containing update operators
+// (https://docs.mongodb.com/manual/reference/operator/update/) and can be used to specify the modifications to be
+// made to the selected document. It cannot be nil or empty.
+//
+// The opts parameter can be used to specify options for the operation (see the options.UpdateOptions documentation).
+//
+// For more information about the command, see https://docs.mongodb.com/manual/reference/command/update/.
+func (coll *Collection) UpdateByID(ctx context.Context, id interface{}, update interface{},
+	opts ...*options.UpdateOptions) (*UpdateResult, error) {
+	if id == nil {
+		return nil, ErrNilValue
+	}
+	return coll.UpdateOne(ctx, bson.D{{"_id", id}}, update, opts...)
+}
+
 // UpdateOne executes an update command to update at most one document in the collection.
 //
 // The filter parameter must be a document containing query operators and can be used to select the document to be

mongo/integration/collection_test.go

@@ -484,6 +484,93 @@ func TestCollection(t *testing.T) {
 			}
 		})
 	})
+	mt.RunOpts("update by id", noClientOpts, func(mt *mtest.T) {
+		mt.Run("empty update", func(mt *mtest.T) {
+			_, err := mt.Coll.UpdateByID(mtest.Background, "foo", bson.D{})
+			assert.NotNil(mt, err, "expected error, got nil")
+		})
+		mt.Run("nil id", func(mt *mtest.T) {
+			_, err := mt.Coll.UpdateByID(mtest.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(mtest.Background, doc)
+					assert.Nil(mt, err, "InsertOne error: %v", err)
+
+					update := bson.D{{"$inc", bson.D{{"x", 1}}}}
+
+					res, err := mt.Coll.UpdateByID(mtest.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(mtest.Background, doc)
+			assert.Nil(mt, err, "InsertOne error: %v", err)
+
+			update := bson.D{{"$inc", bson.D{{"x", 1}}}}
+
+			res, err := mt.Coll.UpdateByID(mtest.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(mtest.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(mtest.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(mtest.Background, bson.D{{"_id", id}})
+			assert.Nil(mt, err, "InsertOne error: %v", err)
+
+			_, err = mt.Coll.UpdateByID(mtest.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(mtest.Background, bson.D{{"_id", id}})
+			assert.Nil(mt, err, "InsertOne error: %v", err)
+
+			mt.CloneCollection(options.Collection().SetWriteConcern(impossibleWc))
+			_, err = mt.Coll.UpdateByID(mtest.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(mtest.Background, bson.D{}, bson.D{})