RUST-1406 Update driver to match errors (#1394)

abr-egn · web-flow · commit 233200f77c0d · 2025-06-10T11:50:03.000-04:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/macros/src/option.rs b/macros/src/option.rs
@@ -92,11 +92,7 @@ pub fn option_setters(
     });
     // Append setter fns to `impl` block item list
     for OptInfo { name, attrs, type_ } in opt_info {
-        if args
-            .skip
-            .as_ref()
-            .map_or(false, |skip| skip.contains(&name))
-        {
+        if args.skip.as_ref().is_some_and(|skip| skip.contains(&name)) {
             continue;
         }
         let (accept, value) = if type_.is_ident("String")
diff --git a/src/action/run_command.rs b/src/action/run_command.rs
@@ -3,6 +3,7 @@ use std::time::Duration;
 use crate::bson::{Bson, Document, RawDocumentBuf};
 
 use crate::{
+    bson_compat::RawResult,
     client::session::TransactionState,
     coll::options::CursorType,
     db::options::{RunCommandOptions, RunCursorCommandOptions},
@@ -154,7 +155,7 @@ impl crate::sync::Database {
 #[must_use]
 pub struct RunCommand<'a> {
     db: &'a Database,
-    command: crate::bson::raw::Result<RawDocumentBuf>,
+    command: RawResult<RawDocumentBuf>,
     options: Option<RunCommandOptions>,
     session: Option<&'a mut ClientSession>,
 }
@@ -214,7 +215,7 @@ impl<'a> Action for RunCommand<'a> {
 #[must_use]
 pub struct RunCursorCommand<'a, Session = ImplicitSession> {
     db: &'a Database,
-    command: crate::bson::raw::Result<RawDocumentBuf>,
+    command: RawResult<RawDocumentBuf>,
     options: Option<RunCursorCommandOptions>,
     session: Session,
 }
diff --git a/src/bson_compat.rs b/src/bson_compat.rs
@@ -1,3 +1,4 @@
+#[cfg(feature = "bson-3")]
 pub(crate) trait RawDocumentBufExt {
     fn append_ref<'a>(
         &mut self,
@@ -6,6 +7,7 @@ pub(crate) trait RawDocumentBufExt {
     );
 }
 
+#[cfg(feature = "bson-3")]
 impl RawDocumentBufExt for crate::bson::RawDocumentBuf {
     fn append_ref<'a>(
         &mut self,
@@ -15,3 +17,15 @@ impl RawDocumentBufExt for crate::bson::RawDocumentBuf {
         self.append(key, value)
     }
 }
+
+#[cfg(feature = "bson-3")]
+pub(crate) use crate::bson::error::Result as RawResult;
+
+#[cfg(not(feature = "bson-3"))]
+pub(crate) use crate::bson::raw::Result as RawResult;
+
+#[cfg(feature = "bson-3")]
+pub(crate) use crate::bson::error::Error as RawError;
+
+#[cfg(not(feature = "bson-3"))]
+pub(crate) use crate::bson::raw::Error as RawError;
diff --git a/src/change_stream/event.rs b/src/change_stream/event.rs
@@ -4,9 +4,9 @@ use std::convert::TryInto;
 
 use crate::{cursor::CursorSpecification, options::ChangeStreamOptions};
 
-#[cfg(test)]
-use crate::bson::Bson;
 use crate::bson::{DateTime, Document, RawBson, RawDocumentBuf, Timestamp};
+#[cfg(test)]
+use crate::{bson::Bson, bson_compat::RawError};
 use serde::{Deserialize, Serialize};
 
 /// An opaque token used for resuming an interrupted
@@ -43,7 +43,7 @@ impl ResumeToken {
     }
 
     #[cfg(test)]
-    pub(crate) fn parsed(self) -> std::result::Result<Bson, crate::bson::raw::Error> {
+    pub(crate) fn parsed(self) -> std::result::Result<Bson, RawError> {
         self.0.try_into()
     }
 }
diff --git a/src/client/auth/oidc.rs b/src/client/auth/oidc.rs
@@ -976,7 +976,11 @@ pub(super) fn validate_credential(credential: &Credential) -> Result<()> {
         )));
     }
     #[cfg(test)]
-    if environment == Ok(TEST_ENVIRONMENT_VALUE_STR) && credential.username.is_some() {
+    if environment
+        .as_ref()
+        .is_ok_and(|ev| *ev == TEST_ENVIRONMENT_VALUE_STR)
+        && credential.username.is_some()
+    {
         return Err(Error::invalid_argument(format!(
             "username must not be set for {} authentication in the {} {}",
             MONGODB_OIDC_STR, TEST_ENVIRONMENT_VALUE_STR, ENVIRONMENT_PROP_STR,
diff --git a/src/cmap/establish/handshake/test.rs b/src/cmap/establish/handshake/test.rs
@@ -32,12 +32,15 @@ async fn metadata_no_options() {
             .collect::<Vec<_>>(),
         vec!["name", "version"]
     );
-    assert_eq!(driver.get_str("name"), Ok("mongo-rust-driver"));
-    assert_eq!(driver.get_str("version"), Ok(env!("CARGO_PKG_VERSION")));
+    assert_eq!(driver.get_str("name").unwrap(), "mongo-rust-driver");
+    assert_eq!(
+        driver.get_str("version").unwrap(),
+        env!("CARGO_PKG_VERSION")
+    );
 
     let os = metadata.get_document("os").unwrap();
-    assert_eq!(os.get_str("type"), Ok(std::env::consts::OS));
-    assert_eq!(os.get_str("architecture"), Ok(std::env::consts::ARCH));
+    assert_eq!(os.get_str("type").unwrap(), std::env::consts::OS);
+    assert_eq!(os.get_str("architecture").unwrap(), std::env::consts::ARCH);
 }
 
 #[tokio::test]
@@ -68,8 +71,8 @@ async fn metadata_with_options() {
     let command = handshaker.build_command(None).await.unwrap().0;
     let metadata = command.body.get_document("client").unwrap();
     assert_eq!(
-        metadata.get_document("application"),
-        Ok(rawdoc! { "name": app_name }.deref())
+        metadata.get_document("application").unwrap(),
+        rawdoc! { "name": app_name }.deref()
     );
 
     let driver = metadata.get_document("driver").unwrap();
@@ -81,15 +84,15 @@ async fn metadata_with_options() {
         vec!["name", "version"]
     );
     assert_eq!(
-        driver.get_str("name"),
-        Ok(format!("mongo-rust-driver|{}", name).as_str())
+        driver.get_str("name").unwrap(),
+        format!("mongo-rust-driver|{}", name).as_str()
     );
     assert_eq!(
-        driver.get_str("version"),
-        Ok(format!("{}|{}", env!("CARGO_PKG_VERSION"), version).as_str())
+        driver.get_str("version").unwrap(),
+        format!("{}|{}", env!("CARGO_PKG_VERSION"), version).as_str()
     );
 
     let os = metadata.get_document("os").unwrap();
-    assert_eq!(os.get_str("type"), Ok(std::env::consts::OS));
-    assert_eq!(os.get_str("architecture"), Ok(std::env::consts::ARCH));
+    assert_eq!(os.get_str("type").unwrap(), std::env::consts::OS);
+    assert_eq!(os.get_str("architecture").unwrap(), std::env::consts::ARCH);
 }
diff --git a/src/error.rs b/src/error.rs
@@ -560,8 +560,8 @@ impl From<crate::bson::ser::Error> for ErrorKind {
     }
 }
 
-impl From<crate::bson::raw::Error> for ErrorKind {
-    fn from(err: crate::bson::raw::Error) -> Self {
+impl From<crate::bson_compat::RawError> for ErrorKind {
+    fn from(err: crate::bson_compat::RawError) -> Self {
         Self::InvalidResponse {
             message: err.to_string(),
         }
diff --git a/src/lib.rs b/src/lib.rs
@@ -21,7 +21,6 @@ pub mod options;
 pub use ::mongocrypt;
 
 pub mod action;
-#[cfg(feature = "bson-3")]
 pub(crate) mod bson_compat;
 mod bson_util;
 pub mod change_stream;
diff --git a/src/sdam/test.rs b/src/sdam/test.rs
@@ -192,7 +192,7 @@ async fn hello_ok_true() {
     event_stream
         .next_match(Duration::from_millis(2000), |event| {
             if let Event::Sdam(SdamEvent::ServerHeartbeatSucceeded(e)) = event {
-                assert_eq!(e.reply.get_bool("helloOk"), Ok(true));
+                assert!(e.reply.get_bool("helloOk").unwrap());
                 assert!(e.reply.get(LEGACY_HELLO_COMMAND_NAME_LOWERCASE).is_some());
                 assert!(e.reply.get("isWritablePrimary").is_none());
                 return true;
diff --git a/src/test/client.rs b/src/test/client.rs
@@ -980,5 +980,5 @@ async fn ipv6_connect() {
         .run_command(doc! { "ping": 1 })
         .await
         .unwrap();
-    assert_eq!(result.get_f64("ok"), Ok(1.0));
+    assert_eq!(result.get_f64("ok").unwrap(), 1.0);
 }
diff --git a/src/test/csfle/prose.rs b/src/test/csfle/prose.rs
@@ -1750,8 +1750,8 @@ mod range_explicit_encryption {
             assert_eq!(actual.len(), expected.len());
             for (idx, num) in expected.iter().enumerate() {
                 assert_eq!(
-                    actual[idx].get(&key),
-                    Ok(Some(bson_numbers[num].as_raw_bson_ref()))
+                    actual[idx].get(&key).unwrap(),
+                    Some(bson_numbers[num].as_raw_bson_ref())
                 );
             }
         };
diff --git a/src/test/db.rs b/src/test/db.rs
@@ -451,7 +451,7 @@ async fn test_run_command() {
             .unwrap();
         let v: Vec<Result<Document>> = cursor.collect().await;
         assert_eq!(v.len(), 1);
-        assert_eq!(v[0].as_ref().unwrap().get_str("foo"), Ok("bar"));
+        assert_eq!(v[0].as_ref().unwrap().get_str("foo").unwrap(), "bar");
     }
 
     // Test run_raw_cursor_command
@@ -463,6 +463,6 @@ async fn test_run_command() {
         let cursor = database.run_raw_cursor_command(cmd).await.unwrap();
         let v: Vec<Result<Document>> = cursor.collect().await;
         assert_eq!(v.len(), 1);
-        assert_eq!(v[0].as_ref().unwrap().get_str("foo"), Ok("bar"));
+        assert_eq!(v[0].as_ref().unwrap().get_str("foo").unwrap(), "bar");
     }
 }
diff --git a/src/test/index_management/search_index.rs b/src/test/index_management/search_index.rs
@@ -36,7 +36,9 @@ async fn search_index_create_list() {
     let found = 'outer: loop {
         let mut cursor = coll0.list_search_indexes().await.unwrap();
         while let Some(d) = cursor.try_next().await.unwrap() {
-            if d.get_str("name") == Ok("test-search-index") && d.get_bool("queryable") == Ok(true) {
+            if d.get_str("name").is_ok_and(|n| n == "test-search-index")
+                && d.get_bool("queryable").unwrap_or(false)
+            {
                 break 'outer d;
             }
         }
@@ -47,8 +49,8 @@ async fn search_index_create_list() {
     };
 
     assert_eq!(
-        found.get_document("latestDefinition"),
-        Ok(&doc! { "mappings": { "dynamic": false } })
+        found.get_document("latestDefinition").unwrap(),
+        &doc! { "mappings": { "dynamic": false } }
     );
 }
 
@@ -84,11 +86,12 @@ async fn search_index_create_multiple() {
     loop {
         let mut cursor = coll0.list_search_indexes().await.unwrap();
         while let Some(d) = cursor.try_next().await.unwrap() {
-            if d.get_str("name") == Ok("test-search-index-1") && d.get_bool("queryable") == Ok(true)
+            if d.get_str("name").is_ok_and(|n| n == "test-search-index-1")
+                && d.get_bool("queryable").unwrap_or(false)
             {
                 index1 = Some(d);
-            } else if d.get_str("name") == Ok("test-search-index-2")
-                && d.get_bool("queryable") == Ok(true)
+            } else if d.get_str("name").is_ok_and(|n| n == "test-search-index-2")
+                && d.get_bool("queryable").unwrap_or(false)
             {
                 index2 = Some(d);
             }
@@ -103,12 +106,12 @@ async fn search_index_create_multiple() {
     }
 
     assert_eq!(
-        index1.unwrap().get_document("latestDefinition"),
-        Ok(&doc! { "mappings": { "dynamic": false } })
+        index1.unwrap().get_document("latestDefinition").unwrap(),
+        &doc! { "mappings": { "dynamic": false } }
     );
     assert_eq!(
-        index2.unwrap().get_document("latestDefinition"),
-        Ok(&doc! { "mappings": { "dynamic": false } })
+        index2.unwrap().get_document("latestDefinition").unwrap(),
+        &doc! { "mappings": { "dynamic": false } }
     );
 }
 
@@ -138,7 +141,9 @@ async fn search_index_drop() {
     'outer: loop {
         let mut cursor = coll0.list_search_indexes().await.unwrap();
         while let Some(d) = cursor.try_next().await.unwrap() {
-            if d.get_str("name") == Ok("test-search-index") && d.get_bool("queryable") == Ok(true) {
+            if d.get_str("name").is_ok_and(|n| n == "test-search-index")
+                && d.get_bool("queryable").unwrap_or(false)
+            {
                 break 'outer;
             }
         }
@@ -188,7 +193,9 @@ async fn search_index_update() {
     'outer: loop {
         let mut cursor = coll0.list_search_indexes().await.unwrap();
         while let Some(d) = cursor.try_next().await.unwrap() {
-            if d.get_str("name") == Ok("test-search-index") && d.get_bool("queryable") == Ok(true) {
+            if d.get_str("name").is_ok_and(|n| n == "test-search-index")
+                && d.get_bool("queryable").unwrap_or(false)
+            {
                 break 'outer;
             }
         }
@@ -209,9 +216,9 @@ async fn search_index_update() {
     let found = 'find: loop {
         let mut cursor = coll0.list_search_indexes().await.unwrap();
         while let Some(d) = cursor.try_next().await.unwrap() {
-            if d.get_str("name") == Ok("test-search-index")
-                && d.get_bool("queryable") == Ok(true)
-                && d.get_str("status") == Ok("READY")
+            if d.get_str("name").is_ok_and(|n| n == "test-search-index")
+                && d.get_bool("queryable").unwrap_or(false)
+                && d.get_str("status").is_ok_and(|s| s == "READY")
             {
                 break 'find d;
             }
@@ -223,8 +230,8 @@ async fn search_index_update() {
     };
 
     assert_eq!(
-        found.get_document("latestDefinition"),
-        Ok(&doc! { "mappings": { "dynamic": true } })
+        found.get_document("latestDefinition").unwrap(),
+        &doc! { "mappings": { "dynamic": true } }
     );
 }
 
@@ -245,7 +252,9 @@ async fn wait_for_index(coll: &Collection<Document>, name: &str) -> Document {
     while Instant::now() < deadline {
         let mut cursor = coll.list_search_indexes().name(name).await.unwrap();
         while let Some(def) = cursor.try_next().await.unwrap() {
-            if def.get_str("name") == Ok(name) && def.get_bool("queryable") == Ok(true) {
+            if def.get_str("name").is_ok_and(|n| n == name)
+                && def.get_bool("queryable").unwrap_or(false)
+            {
                 return def;
             }
         }
@@ -274,7 +283,7 @@ async fn search_index_create_with_type() {
         .unwrap();
     assert_eq!(name, "test-search-index-case7-implicit");
     let index1 = wait_for_index(&coll0, &name).await;
-    assert_eq!(index1.get_str("type"), Ok("search"));
+    assert_eq!(index1.get_str("type").unwrap(), "search");
 
     let name = coll0
         .create_search_index(
@@ -288,7 +297,7 @@ async fn search_index_create_with_type() {
         .unwrap();
     assert_eq!(name, "test-search-index-case7-explicit");
     let index2 = wait_for_index(&coll0, &name).await;
-    assert_eq!(index2.get_str("type"), Ok("search"));
+    assert_eq!(index2.get_str("type").unwrap(), "search");
 
     let name = coll0
         .create_search_index(
@@ -309,7 +318,7 @@ async fn search_index_create_with_type() {
         .unwrap();
     assert_eq!(name, "test-search-index-case7-vector");
     let index3 = wait_for_index(&coll0, &name).await;
-    assert_eq!(index3.get_str("type"), Ok("vectorSearch"));
+    assert_eq!(index3.get_str("type").unwrap(), "vectorSearch");
 }
 
 // SearchIndex Case 8: Driver requires explicit type to create a vector search index
diff --git a/src/test/spec/retryable_writes.rs b/src/test/spec/retryable_writes.rs
@@ -246,7 +246,9 @@ async fn retry_write_retryable_write_error() {
             while let Some(msg) = event_rx.recv().await {
                 if let CommandEvent::Succeeded(ev) = &*msg {
                     if let Some(Bson::Document(wc_err)) = ev.reply.get("writeConcernError") {
-                        if ev.command_name == "insert" && wc_err.get_i32("code") == Ok(91) {
+                        if ev.command_name == "insert"
+                            && wc_err.get_i32("code").is_ok_and(|c| c == 91)
+                        {
                             // Spawn a new task so events continue to process
                             let client = client.clone();
                             let fp_tx = fp_tx.clone();

Original file line number	Diff line number	Diff line change
`@@ -4,9 +4,9 @@ use std::convert::TryInto;`
`4`	`4`
`5`	`5`	`use crate::{cursor::CursorSpecification, options::ChangeStreamOptions};`
`6`	`6`
`7`		`-#[cfg(test)]`
`8`		`-use crate::bson::Bson;`
`9`	`7`	`use crate::bson::{DateTime, Document, RawBson, RawDocumentBuf, Timestamp};`
	`8`	`+#[cfg(test)]`
	`9`	`+use crate::{bson::Bson, bson_compat::RawError};`
`10`	`10`	`use serde::{Deserialize, Serialize};`
`11`	`11`
`12`	`12`	`/// An opaque token used for resuming an interrupted`
`@@ -43,7 +43,7 @@ impl ResumeToken {`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`#[cfg(test)]`
`46`		`- pub(crate) fn parsed(self) -> std::result::Result<Bson, crate::bson::raw::Error> {`
	`46`	`+ pub(crate) fn parsed(self) -> std::result::Result<Bson, RawError> {`
`47`	`47`	`self.0.try_into()`
`48`	`48`	`}`
`49`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -560,8 +560,8 @@ impl From<crate::bson::ser::Error> for ErrorKind {`
`560`	`560`	`}`
`561`	`561`	`}`
`562`	`562`
`563`		`-impl From<crate::bson::raw::Error> for ErrorKind {`
`564`		`- fn from(err: crate::bson::raw::Error) -> Self {`
	`563`	`+impl From<crate::bson_compat::RawError> for ErrorKind {`
	`564`	`+ fn from(err: crate::bson_compat::RawError) -> Self {`
`565`	`565`	`Self::InvalidResponse {`
`566`	`566`	`message: err.to_string(),`
`567`	`567`	`}`