CSHARP-797: Add unit test for { j : 1 } when server is run with --nojournal.

Author: rstam

MongoDB.Driver/Exceptions/ExceptionMapper.cs

@@ -90,11 +90,25 @@ public static Exception Map(WriteConcernResult writeConcernResult)
                 return new WriteConcernException(errorMessage, writeConcernResult);
             }
 
+            string lastErrorMessage = null;
             if (writeConcernResult.HasLastErrorMessage)
+            {
+                lastErrorMessage = writeConcernResult.LastErrorMessage;
+            }
+            else if (writeConcernResult.Response.Contains("jnote"))
+            {
+                lastErrorMessage = writeConcernResult.Response["jnote"].ToString();
+            }
+            else if (writeConcernResult.Response.Contains("wnote"))
+            {
+                lastErrorMessage = writeConcernResult.Response["wnote"].ToString();
+            }
+
+            if (lastErrorMessage != null)
             {
                 var errorMessage = string.Format(
                     "WriteConcern detected an error '{0}'. (Response was {1}).",
-                    writeConcernResult.LastErrorMessage, writeConcernResult.Response.ToJson());
+                    lastErrorMessage, writeConcernResult.Response.ToJson());
                 return new WriteConcernException(errorMessage, writeConcernResult);
             }
 

MongoDB.Driver/Operations/BulkWriteBatchResult.cs

@@ -378,7 +378,22 @@ private static WriteConcernError CreateWriteConcernError(BsonDocument writeComma
         private static WriteConcernError CreateWriteConcernErrorFromGetLastErrorResponse(BsonDocument getLastErrorResponse)
         {
             var code = getLastErrorResponse.GetValue("code", 64).ToInt32(); // default = WriteConcernFailed
-            var message = (string)getLastErrorResponse.GetValue("err", null);
+
+            string message = null;
+            BsonValue value;
+            if (getLastErrorResponse.TryGetValue("err", out value) && value.BsonType == BsonType.String)
+            {
+                message = value.AsString;
+            }
+            else if (getLastErrorResponse.TryGetValue("jnote", out value) && value.BsonType == BsonType.String)
+            {
+                message = value.AsString;
+            }
+            else if (getLastErrorResponse.TryGetValue("wnote", out value) && value.BsonType == BsonType.String)
+            {
+                message = value.AsString;
+            }
+
             var details = new BsonDocument(getLastErrorResponse.Where(e => !new[] { "ok", "code", "err" }.Contains(e.Name)));
 
             return new WriteConcernError(code, message, details);

MongoDB.DriverUnitTests/Operations/BulkWriteOperationTests.cs

@@ -412,6 +412,58 @@ public void TestMixedUpsertsUnordered()
             }
         }
 
+        [Test]
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestNoJournal(bool ordered)
+        {
+            using (_server.RequestStart(null, ReadPreference.Primary))
+            {
+                var serverInstance = _server.RequestConnection.ServerInstance;
+                if (serverInstance.InstanceType == MongoServerInstanceType.StandAlone)
+                {
+                    _collection.Drop();
+                    var documents = new[]
+                    {
+                        new BsonDocument("x", 1)
+                    };
+
+                    var bulk = InitializeBulkOperation(_collection, ordered);
+                    bulk.Insert(documents[0]);
+
+                    var writeConcern = new WriteConcern { Journal = true };
+                    if (IsJournalEnabled(serverInstance))
+                    {
+                        var result = bulk.Execute(writeConcern);
+                        var expectedResult = new ExpectedResult { InsertedCount = 1, RequestCount = 1 };
+                        CheckExpectedResult(expectedResult, result);
+                        Assert.That(_collection.FindAll(), Is.EquivalentTo(documents));
+                    }
+                    else
+                    {
+                        if (serverInstance.Supports(FeatureId.WriteCommands))
+                        {
+                            Assert.Throws<MongoCommandException>(() => { bulk.Execute(writeConcern); });
+                            Assert.AreEqual(0, _collection.Count());
+                        }
+                        else
+                        {
+                            var exception = Assert.Throws<BulkWriteException>(() => { bulk.Execute(writeConcern); });
+                            var result = exception.Result;
+
+                            var expectedResult = new ExpectedResult { InsertedCount = 1, RequestCount = 1 };
+                            CheckExpectedResult(expectedResult, result);
+                            Assert.That(_collection.FindAll(), Is.EquivalentTo(documents));
+
+                            Assert.AreEqual(0, exception.UnprocessedRequests.Count);
+                            Assert.IsNotNull(exception.WriteConcernError);
+                            Assert.AreEqual(0, exception.WriteErrors.Count);
+                        }
+                    }
+                }
+            }
+        }
+
         [Test]
         public void TestOrderedBatchWithErrors()
         {
@@ -1185,6 +1237,35 @@ public void TestUpsertWithOneMatchingDocument(bool ordered)
             }
         }
 
+        [Test]
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestW0DoesNotReportErrors(bool ordered)
+        {
+            using (_server.RequestStart(null, ReadPreference.Primary))
+            {
+                var serverInstance = _server.RequestConnection.ServerInstance;
+
+                var documents = new[]
+                {
+                    new BsonDocument("_id", 1),
+                    new BsonDocument("_id", 1)
+                };
+
+                _collection.Drop();
+                var bulk = InitializeBulkOperation(_collection, ordered);
+                bulk.Insert(documents[0]);
+                bulk.Insert(documents[1]);
+                var result = bulk.Execute(WriteConcern.Unacknowledged);
+
+                var expectedResult = new ExpectedResult { IsAcknowledged = false, RequestCount = 2 };
+                CheckExpectedResult(expectedResult, result);
+
+                var expectedDocuments = new[] { documents[0] };
+                Assert.That(_collection.FindAll(), Is.EquivalentTo(expectedDocuments));
+            }
+        }
+
         [Test]
         [TestCase(false)]
         [TestCase(true)]
@@ -1203,7 +1284,7 @@ public void TestW2AgainstStandalone(bool ordered)
 
                     if (serverInstance.Supports(FeatureId.WriteCommands))
                     {
-                        var exception = Assert.Throws<MongoCommandException>(() => { bulk.Execute(WriteConcern.W2); });
+                        Assert.Throws<MongoCommandException>(() => { bulk.Execute(WriteConcern.W2); });
                         Assert.AreEqual(0, _collection.Count());
                     }
                     else
@@ -1264,6 +1345,28 @@ private BulkWriteOperation InitializeBulkOperation(MongoCollection collection, b
             return ordered ? collection.InitializeOrderedBulkOperation() : _collection.InitializeUnorderedBulkOperation();
         }
 
+        private bool IsJournalEnabled(MongoServerInstance serverInstance)
+        {
+            using (_server.RequestStart(null, serverInstance))
+            {
+                var adminDatabase = _server.GetDatabase("admin");
+                var command = new CommandDocument("getCmdLineOpts", 1);
+                var result = adminDatabase.RunCommand(command);
+
+                BsonValue parsed;
+                if (result.Response.TryGetValue("parsed", out parsed))
+                {
+                    BsonValue nojournal;
+                    if (parsed.AsBsonDocument.TryGetValue("nojournal", out nojournal))
+                    {
+                        return !nojournal.ToBoolean();
+                    }
+                }
+
+                return true;
+            }
+        }
+
         // nested classes
         private class ExpectedResult
         {