RUST-662 Expose errInfo as details in WriteError (#375)

* RUST-662 Expose errInfo as details in WriteError

* Add a rountrip test for write error details

Author: abr-egn

src/error.rs

@@ -472,6 +472,11 @@ pub struct WriteError {
     /// A description of the error that occurred.
     #[serde(rename = "errmsg")]
     pub message: String,
+
+    /// A document providing more information about the write error (e.g. details
+    /// pertaining to document validation).
+    #[serde(rename = "errInfo")]
+    pub details: Option<Document>,
 }
 
 /// An error that occurred during a write operation consisting of multiple writes that wasn't due to
@@ -496,6 +501,11 @@ pub struct BulkWriteError {
     /// A description of the error that occurred.
     #[serde(rename = "errmsg")]
     pub message: String,
+
+    /// A document providing more information about the write error (e.g. details
+    /// pertaining to document validation).
+    #[serde(rename = "errInfo")]
+    pub details: Option<Document>,
 }
 
 /// The set of errors that occurred during a write operation.
@@ -542,6 +552,7 @@ impl WriteFailure {
                 code: bulk_write_error.code,
                 code_name: bulk_write_error.code_name,
                 message: bulk_write_error.message,
+                details: bulk_write_error.details,
             };
             Ok(WriteFailure::WriteError(write_error))
         } else if let Some(wc_error) = bulk.write_concern_error {

src/operation/delete/test.rs

@@ -149,6 +149,7 @@ async fn handle_write_failure() {
                 code: 1234,
                 code_name: None,
                 message: "my error string".to_string(),
+                details: None,
             };
             assert_eq!(error, &expected_err);
         }

src/operation/insert/test.rs

@@ -187,7 +187,10 @@ async fn handle_write_failure() {
             {
                 "index": 1,
                 "code": 11000,
-                "errmsg": "duplicate key"
+                "errmsg": "duplicate key",
+                "errInfo": {
+                    "test key": "test value",
+                }
             }
         ],
         "writeConcernError": {
@@ -218,6 +221,7 @@ async fn handle_write_failure() {
                 code: 11000,
                 code_name: None,
                 message: "duplicate key".to_string(),
+                details: Some(doc! { "test key": "test value" }),
             };
             assert_eq!(write_errors.first().unwrap(), &expected_err);
 

src/operation/update/test.rs

@@ -232,6 +232,7 @@ async fn handle_write_failure() {
                 code: 1234,
                 code_name: None,
                 message: "my error string".to_string(),
+                details: None,
             };
             assert_eq!(error, &expected_err);
         }

src/test/spec/mod.rs

@@ -17,6 +17,7 @@ mod transactions;
 mod unified_runner;
 mod v2_runner;
 mod versioned_api;
+mod write_error;
 
 use std::{
     convert::TryFrom,

src/test/spec/write_error.rs

@@ -0,0 +1,51 @@
+use crate::{
+    bson::{doc, Document},
+    error::{ErrorKind, WriteFailure},
+    options::CreateCollectionOptions,
+    test::{EventClient, LOCK},
+    Collection,
+};
+
+#[cfg_attr(feature = "tokio-runtime", tokio::test)]
+#[cfg_attr(feature = "async-std-runtime", async_std::test)]
+async fn details() {
+    let _guard = LOCK.run_concurrently().await;
+    let client = EventClient::new().await;
+    if client.server_version_lt(5, 0) {
+        return;
+    }
+
+    let db = client.database("write_error_details");
+    db.drop(None).await.unwrap();
+    db.create_collection(
+        "test",
+        CreateCollectionOptions::builder()
+            .validator(doc! {
+                "x": { "$type": "string" }
+            })
+            .build(),
+    )
+    .await
+    .unwrap();
+    let coll: Collection<Document> = db.collection("test");
+    let err = coll.insert_one(doc! { "x": 1 }, None).await.unwrap_err();
+    let write_err = match *err.kind {
+        ErrorKind::Write(WriteFailure::WriteError(e)) => e,
+        _ => panic!("expected WriteError, got {:?}", err.kind),
+    };
+    let (_, event) = client.get_successful_command_execution("insert");
+    assert_eq!(write_err.code, 121 /* DocumentValidationFailure */);
+    assert_eq!(
+        &write_err.details.unwrap(),
+        event
+            .reply
+            .get_array("writeErrors")
+            .unwrap()
+            .get(0)
+            .unwrap()
+            .as_document()
+            .unwrap()
+            .get_document("errInfo")
+            .unwrap()
+    );
+}