Ensure write operation error are returned

GODRIVER-312
GODRIVER-307
GODRIVER-347

Change-Id: Ib3321215285029b9602f27ca4a89d588ef643238

Author: skriptble

core/integration/command_test.go

@@ -13,13 +13,16 @@ import (
 	"github.com/mongodb/mongo-go-driver/bson"
 	"github.com/mongodb/mongo-go-driver/core/addr"
 	"github.com/mongodb/mongo-go-driver/core/command"
+	"github.com/mongodb/mongo-go-driver/core/description"
+	"github.com/mongodb/mongo-go-driver/core/result"
 	"github.com/mongodb/mongo-go-driver/core/topology"
+	"github.com/mongodb/mongo-go-driver/internal/testutil"
 	"github.com/stretchr/testify/require"
 )
 
 func TestCommand(t *testing.T) {
 	noerr := func(t *testing.T, err error) {
-		// t.Helper()
+		t.Helper()
 		if err != nil {
 			t.Errorf("Unepexted error: %v", err)
 			t.FailNow()
@@ -74,3 +77,31 @@ func TestCommand(t *testing.T) {
 	require.Equal(t, elem.Value().Type(), bson.TypeDouble)
 	require.Equal(t, float64(1), elem.Value().Double(), "Unable to ping MongoDB")
 }
+
+func TestWriteCommands(t *testing.T) {
+	t.Run("Insert", func(t *testing.T) {
+		t.Run("Should return write error", func(t *testing.T) {
+			ctx := context.TODO()
+			server, err := testutil.Topology(t).SelectServer(context.Background(), description.WriteSelector())
+			noerr(t, err)
+			conn, err := server.Connection(context.Background())
+			noerr(t, err)
+			cmd := &command.Insert{
+				NS:   command.Namespace{DB: dbName, Collection: testutil.ColName(t)},
+				Docs: []*bson.Document{bson.NewDocument(bson.EC.String("_id", "helloworld"))},
+			}
+			_, err = cmd.RoundTrip(ctx, server.SelectedDescription(), conn)
+			noerr(t, err)
+			res, err := cmd.RoundTrip(ctx, server.SelectedDescription(), conn)
+			noerr(t, err)
+			if len(res.WriteErrors) != 1 {
+				t.Errorf("Expected to get a write error. got %d; want %d", len(res.WriteErrors), 1)
+				t.FailNow()
+			}
+			want := result.WriteError{Code: 11000}
+			if res.WriteErrors[0].Code != want.Code {
+				t.Errorf("Expected error codes to match. want %d; got %d", res.WriteErrors[0].Code, want.Code)
+			}
+		})
+	})
+}

core/result/result.go

@@ -16,12 +16,27 @@ import (
 
 // Insert is a result from an Insert command.
 type Insert struct {
-	N int
+	N                 int
+	WriteErrors       []WriteError       `bson:"writeErrors"`
+	WriteConcernError *WriteConcernError `bson:"writeConcernError"`
 }
 
 // Delete is a result from a Delete command.
 type Delete struct {
-	N int
+	N                 int
+	WriteErrors       []WriteError       `bson:"writeErrors"`
+	WriteConcernError *WriteConcernError `bson:"writeConcernError"`
+}
+
+// Update is a result of an Update command.
+type Update struct {
+	MatchedCount  int64 `bson:"n"`
+	ModifiedCount int64 `bson:"nModified"`
+	Upserted      []struct {
+		ID interface{} `bson:"_id"`
+	} `bson:"upserted"`
+	WriteErrors       []WriteError       `bson:"writeErrors"`
+	WriteConcernError *WriteConcernError `bson:"writeConcernError"`
 }
 
 // Distinct is a result from a Distinct command.
@@ -38,8 +53,20 @@ type FindAndModify struct {
 	}
 }
 
-// Document is a result from a command that returns a single Document.
-type Document struct{}
+// WriteError is an error from a write operation that is not a write concern
+// error.
+type WriteError struct {
+	Index  int
+	Code   int
+	ErrMsg string
+}
+
+// WriteConcernError is an error related to a write concern.
+type WriteConcernError struct {
+	Code    int
+	ErrMsg  string
+	ErrInfo bson.Reader
+}
 
 // ListDatabases is the result from a listDatabases command.
 type ListDatabases struct {
@@ -51,15 +78,6 @@ type ListDatabases struct {
 	TotalSize int64 `bson:"totalSize"`
 }
 
-// Update is a result of an Update command.
-type Update struct {
-	MatchedCount  int64 `bson:"n"`
-	ModifiedCount int64 `bson:"nModified"`
-	Upserted      []struct {
-		ID interface{} `bson:"_id"`
-	} `bson:"upserted"`
-}
-
 // IsMaster is a result of an IsMaster command.
 type IsMaster struct {
 	Arbiters            []string          `bson:"arbiters,omitempty"`

mongo/collection.go

@@ -96,8 +96,9 @@ func (coll *Collection) InsertOne(ctx context.Context, document interface{},
 		Opts: newOptions,
 	}
 
-	_, err = dispatch.Insert(ctx, cmd, coll.client.topology, coll.writeSelector, coll.writeConcern)
-	if err != nil && err != dispatch.ErrUnacknowledgedWrite {
+	res, err := dispatch.Insert(ctx, cmd, coll.client.topology, coll.writeSelector, coll.writeConcern)
+	rr, err := processWriteError(res.WriteConcernError, res.WriteErrors, err)
+	if rr&rrOne == 0 {
 		return nil, err
 	}
 	return &InsertOneResult{InsertedID: insertedID}, err
@@ -149,10 +150,20 @@ func (coll *Collection) InsertMany(ctx context.Context, documents []interface{},
 		Opts: newOptions,
 	}
 
-	_, err := dispatch.Insert(ctx, cmd, coll.client.topology, coll.writeSelector, coll.writeConcern)
-	if err != nil && err != dispatch.ErrUnacknowledgedWrite {
+	res, err := dispatch.Insert(ctx, cmd, coll.client.topology, coll.writeSelector, coll.writeConcern)
+	switch err {
+	case nil:
+	case dispatch.ErrUnacknowledgedWrite:
+		return &InsertManyResult{InsertedIDs: result}, ErrUnacknowledgedWrite
+	default:
 		return nil, err
 	}
+	if len(res.WriteErrors) > 0 || res.WriteConcernError != nil {
+		err = BulkWriteError{
+			WriteErrors:       writeErrorsFromResult(res.WriteErrors),
+			WriteConcernError: convertWriteConcernError(res.WriteConcernError),
+		}
+	}
 	return &InsertManyResult{InsertedIDs: result}, err
 }
 
@@ -187,7 +198,8 @@ func (coll *Collection) DeleteOne(ctx context.Context, filter interface{},
 	}
 
 	res, err := dispatch.Delete(ctx, cmd, coll.client.topology, coll.writeSelector, coll.writeConcern)
-	if err != nil && err != dispatch.ErrUnacknowledgedWrite {
+	rr, err := processWriteError(res.WriteConcernError, res.WriteErrors, err)
+	if rr&rrOne == 0 {
 		return nil, err
 	}
 	return &DeleteResult{DeletedCount: int64(res.N)}, err
@@ -221,7 +233,8 @@ func (coll *Collection) DeleteMany(ctx context.Context, filter interface{},
 	}
 
 	res, err := dispatch.Delete(ctx, cmd, coll.client.topology, coll.writeSelector, coll.writeConcern)
-	if err != nil && err != dispatch.ErrUnacknowledgedWrite {
+	rr, err := processWriteError(res.WriteConcernError, res.WriteErrors, err)
+	if rr&rrMany == 0 {
 		return nil, err
 	}
 	return &DeleteResult{DeletedCount: int64(res.N)}, err
@@ -262,6 +275,10 @@ func (coll *Collection) updateOrReplaceOne(ctx context.Context, filter,
 		res.MatchedCount--
 	}
 
+	rr, err := processWriteError(r.WriteConcernError, r.WriteErrors, err)
+	if rr&rrOne == 0 {
+		return nil, err
+	}
 	return res, err
 }
 
@@ -351,6 +368,10 @@ func (coll *Collection) UpdateMany(ctx context.Context, filter interface{}, upda
 		res.MatchedCount--
 	}
 
+	rr, err := processWriteError(r.WriteConcernError, r.WriteErrors, err)
+	if rr&rrMany == 0 {
+		return nil, err
+	}
 	return res, err
 }