CSHARP-2294: Add ErrorLabels property to MongoException.

Author: rstam

src/MongoDB.Driver.Core/MongoCommandException.cs

@@ -14,17 +14,11 @@
 */
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
 #if NET45
 using System.Runtime.Serialization;
 #endif
-using System.Text;
-using System.Threading.Tasks;
 using MongoDB.Bson;
-using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Core.Connections;
-using MongoDB.Driver.Core.Misc;
 
 namespace MongoDB.Driver
 {
@@ -36,6 +30,27 @@ namespace MongoDB.Driver
 #endif
     public class MongoCommandException : MongoServerException
     {
+        #region static
+        private static void AddErrorLabelsFromCommandResult(MongoCommandException exception, BsonDocument result)
+        {
+            // note: make a best effort to extract the error labels from the result, but never throw an exception
+            if (result != null)
+            {
+                BsonValue errorLabels;
+                if (result.TryGetValue("errorLabels", out errorLabels) && errorLabels.IsBsonArray)
+                {
+                    foreach (var errorLabel in errorLabels.AsBsonArray)
+                    {
+                        if (errorLabel.IsString)
+                        {
+                            exception.AddErrorLabel(errorLabel.AsString);
+                        }
+                    }
+                }
+            }
+        }
+        #endregion
+
         // fields
         private readonly BsonDocument _command;
         private readonly BsonDocument _result;
@@ -64,6 +79,8 @@ public MongoCommandException(ConnectionId connectionId, string message, BsonDocu
         {
             _command = command; // can be null
             _result = result; // can be null
+
+            AddErrorLabelsFromCommandResult(this, result);
         }
 
 #if NET45

src/MongoDB.Driver.Core/MongoException.cs

@@ -14,8 +14,10 @@
 */
 
 using System;
+using System.Collections.Generic;
 #if NET45
 using System.Runtime.Serialization;
+using MongoDB.Driver.Core.Misc;
 #endif
 
 namespace MongoDB.Driver
@@ -28,6 +30,9 @@ namespace MongoDB.Driver
 #endif
     public class MongoException : Exception
     {
+        // private fields
+        private readonly List<string> _errorLabels = new List<string>();
+
         // constructors
         /// <summary>
         /// Initializes a new instance of the <see cref="MongoException"/> class.
@@ -57,6 +62,36 @@ public MongoException(string message, Exception innerException)
         public MongoException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         {
+            _errorLabels = (List<string>)info.GetValue(nameof(_errorLabels), typeof(List<String>));
+        }
+#endif
+
+        // public properties
+        /// <summary>
+        /// Gets the error labels.
+        /// </summary>
+        /// <value>
+        /// The error labels.
+        /// </value>
+        public IReadOnlyList<string> ErrorLabels => _errorLabels;
+
+        // public methods
+        /// <summary>
+        /// Adds an error label.
+        /// </summary>
+        /// <param name="errorLabel">The error label.</param>
+        public void AddErrorLabel(string errorLabel)
+        {
+            Ensure.IsNotNull(errorLabel, nameof(errorLabel));
+            _errorLabels.Add(errorLabel);
+        }
+
+#if NET45
+        /// <inheritdoc/>
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            base.GetObjectData(info, context);
+            info.AddValue(nameof(_errorLabels), _errorLabels);
         }
 #endif
     }

tests/MongoDB.Driver.Core.Tests/MongoCommandExceptionTests.cs

@@ -80,6 +80,27 @@ public void constructor_with_message_command_result_should_initialize_subject()
             subject.Result.Should().BeSameAs(_commandResult);
         }
 
+        [Theory]
+        [InlineData(null, new string[0])]
+        [InlineData("{ }", new string[0])]
+        [InlineData("{ }", new string[0])]
+        [InlineData("{ errorLabels : \"not an array\" }", new string[0])]
+        [InlineData("{ errorLabels : [ ] }", new string[0])]
+        [InlineData("{ errorLabels : [ 1 ] }", new string[0])]
+        [InlineData("{ errorLabels : [ null ] }", new string[0])]
+        [InlineData("{ errorLabels : [ \"one\" ] }", new[] { "one" })]
+        [InlineData("{ errorLabels : [ 1, \"one\" ] }", new[] { "one" })]
+        [InlineData("{ errorLabels : [ \"one\", 1 ] }", new[] { "one" })]
+        [InlineData("{ errorLabels : [ \"one\", null, \"two\" ] }", new[] { "one", "two" })]
+        public void constructor_should_add_error_labels(string jsonResult, string[] expectedErrorLabels)
+        {
+            var result = jsonResult == null ? null : BsonDocument.Parse(jsonResult);
+
+            var subject = new MongoCommandException(_connectionId, _message, _command, result);
+
+            subject.ErrorLabels.Should().Equal(expectedErrorLabels);
+        }
+
         [Fact]
         public void ErrorMessage_get_returns_expected_result()
         {
@@ -95,6 +116,7 @@ public void ErrorMessage_get_returns_expected_result()
         public void Serialization_should_work()
         {
             var subject = new MongoCommandException(_connectionId, _message, _command, _commandResult);
+            subject.AddErrorLabel("one");
 
             var formatter = new BinaryFormatter();
             using (var stream = new MemoryStream())
@@ -103,6 +125,7 @@ public void Serialization_should_work()
                 stream.Position = 0;
                 var rehydrated = (MongoCommandException)formatter.Deserialize(stream);
 
+                rehydrated.ErrorLabels.Should().Equal(subject.ErrorLabels);
                 rehydrated.ConnectionId.Should().Be(subject.ConnectionId);
                 rehydrated.Message.Should().Be(_message);
                 rehydrated.InnerException.Should().BeNull();

tests/MongoDB.Driver.Core.Tests/MongoExceptionTests.cs

@@ -14,11 +14,14 @@
 */
 
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 #if NET45
 using System.Runtime.Serialization.Formatters.Binary;
 #endif
 using FluentAssertions;
+using MongoDB.Bson.TestHelpers.XunitExtensions;
 using Xunit;
 
 namespace MongoDB.Driver
@@ -35,6 +38,7 @@ public void constructor_should_initialize_subject()
 
             subject.Message.Should().BeSameAs(_message);
             subject.InnerException.Should().BeNull();
+            subject.ErrorLabels.Should().HaveCount(0);
         }
 
         [Fact]
@@ -44,13 +48,52 @@ public void constructor_with_innerException_should_initialize_subject()
 
             subject.Message.Should().BeSameAs(_message);
             subject.InnerException.Should().BeSameAs(_innerException);
+            subject.ErrorLabels.Should().HaveCount(0);
+        }
+
+        [Theory]
+        [InlineData(new object[] { new string[0] })]
+        [InlineData(new object[] { new[] { "one" } })]
+        [InlineData(new object[] { new[] { "one", "two" } })]
+        [InlineData(new object[] { new[] { "one", "two", "three" } })]
+        public void ErrorLabels_should_return_expected_result(string[] errorLabels)
+        {
+            var subject = new MongoException(_message);
+            foreach (var errorLabel in errorLabels)
+            {
+                subject.AddErrorLabel(errorLabel);
+            }
+
+            var result = subject.ErrorLabels;
+
+            result.Should().Equal(errorLabels);
+        }
+
+        [Theory]
+        [ParameterAttributeData]
+        public void AddErrorLabels_should_have_expected_result(
+            [Values(0, 1, 2, 3)] int existingCount)
+        {
+            var subject = new MongoException(_message);
+            for (var i = 0; i < existingCount; i++)
+            {
+                var errorLabel = $"label{i}";
+                subject.AddErrorLabel(errorLabel);
+            }
+            var existingErrorLabels = new List<string>(subject.ErrorLabels);
+            var newErrorLabel = "x";
+
+            subject.AddErrorLabel(newErrorLabel);
+
+            subject.ErrorLabels.Should().Equal(existingErrorLabels.Concat(new[] { newErrorLabel }));
         }
 
 #if NET45
         [Fact]
         public void Serialization_should_work()
         {
             var subject = new MongoException(_message, _innerException);
+            subject.AddErrorLabel("one");
 
             var formatter = new BinaryFormatter();
             using (var stream = new MemoryStream())
@@ -61,6 +104,7 @@ public void Serialization_should_work()
 
                 rehydrated.Message.Should().Be(subject.Message);
                 rehydrated.InnerException.Message.Should().Be(subject.InnerException.Message); // Exception does not override Equals
+                rehydrated.ErrorLabels.Should().Equal(subject.ErrorLabels);
             }
         }
 #endif