review updates

Author: abr-egn

src/client/csfle/client_encryption.rs

@@ -32,12 +32,6 @@ pub struct ClientEncryption {
     key_vault: Collection<RawDocumentBuf>,
 }
 
-impl std::fmt::Debug for ClientEncryption {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ClientEncryption").finish()
-    }
-}
-
 impl ClientEncryption {
     /// Create a new key vault handle with the given options.
     pub fn new(options: ClientEncryptionOptions) -> Result<Self> {
@@ -277,27 +271,6 @@ pub struct DataKeyOptions {
     pub key_material: Option<Vec<u8>>,
 }
 
-impl<'de> Deserialize<'de> for DataKeyOptions {
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        #[derive(Deserialize)]
-        #[serde(rename_all = "camelCase")]
-        struct Helper {
-            master_key: Option<MasterKey>,
-            key_alt_names: Option<Vec<String>>,
-            key_material: Option<Binary>,
-        }
-        let h = Helper::deserialize(deserializer)?;
-        Ok(DataKeyOptions {
-            master_key: h.master_key.unwrap_or(MasterKey::Local),
-            key_alt_names: h.key_alt_names,
-            key_material: h.key_material.map(|bin| bin.bytes),
-        })
-    }
-}
-
 /// A KMS-specific key used to encrypt data keys.
 #[serde_with::skip_serializing_none]
 #[derive(Debug, Clone, Serialize, Deserialize)]

src/test/spec/unified_runner/entity.rs

@@ -50,6 +50,13 @@ pub(crate) enum Entity {
     None,
 }
 
+#[cfg(feature = "csfle")]
+impl std::fmt::Debug for crate::client_encryption::ClientEncryption {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ClientEncryption").finish()
+    }
+}
+
 #[derive(Clone, Debug)]
 pub(crate) struct ClientEntity {
     client: Client,
@@ -205,7 +212,7 @@ impl ClientEntity {
         self.client.sync_workers().await;
     }
 
-    #[allow(dead_code)]
+    #[cfg(feature = "csfle")]
     pub(crate) fn client(&self) -> &Client {
         &self.client
     }

src/test/spec/unified_runner/operation.rs

@@ -1,3 +1,8 @@
+#[cfg(feature = "csfle")]
+mod csfle;
+#[cfg(feature = "csfle")]
+use self::csfle::*;
+
 use std::{
     collections::HashMap,
     convert::TryInto,
@@ -2792,189 +2797,6 @@ impl TestOperation for Upload {
     }
 }
 
-#[cfg(feature = "csfle")]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub(super) struct GetKeyByAltName {
-    key_alt_name: String,
-}
-
-#[cfg(feature = "csfle")]
-impl TestOperation for GetKeyByAltName {
-    fn execute_entity_operation<'a>(
-        &'a self,
-        id: &'a str,
-        test_runner: &'a TestRunner,
-    ) -> BoxFuture<'a, Result<Option<Entity>>> {
-        async move {
-            let ce = test_runner.get_client_encryption(id).await;
-            let key = ce.get_key_by_alt_name(&self.key_alt_name).await?;
-            let ent = match key {
-                Some(rd) => Entity::Bson(Bson::Document(rd.to_document()?)),
-                None => Entity::None,
-            };
-            Ok(Some(ent))
-        }
-        .boxed()
-    }
-}
-
-#[cfg(feature = "csfle")]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub(super) struct DeleteKey {
-    id: bson::Binary,
-}
-
-#[cfg(feature = "csfle")]
-impl TestOperation for DeleteKey {
-    fn execute_entity_operation<'a>(
-        &'a self,
-        id: &'a str,
-        test_runner: &'a TestRunner,
-    ) -> BoxFuture<'a, Result<Option<Entity>>> {
-        async move {
-            let ce = test_runner.get_client_encryption(id).await;
-            let result = ce.delete_key(&self.id).await?;
-            Ok(Some(Entity::Bson(Bson::Document(bson::to_document(
-                &result,
-            )?))))
-        }
-        .boxed()
-    }
-}
-
-#[cfg(feature = "csfle")]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub(super) struct GetKey {
-    id: bson::Binary,
-}
-
-#[cfg(feature = "csfle")]
-impl TestOperation for GetKey {
-    fn execute_entity_operation<'a>(
-        &'a self,
-        id: &'a str,
-        test_runner: &'a TestRunner,
-    ) -> BoxFuture<'a, Result<Option<Entity>>> {
-        async move {
-            let ce = test_runner.get_client_encryption(id).await;
-            let entity = match ce.get_key(&self.id).await? {
-                Some(key) => Entity::Bson(Bson::Document(key.to_document()?)),
-                None => Entity::None,
-            };
-            Ok(Some(entity))
-        }
-        .boxed()
-    }
-}
-
-#[cfg(feature = "csfle")]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub(super) struct AddKeyAltName {
-    id: bson::Binary,
-    key_alt_name: String,
-}
-
-#[cfg(feature = "csfle")]
-impl TestOperation for AddKeyAltName {
-    fn execute_entity_operation<'a>(
-        &'a self,
-        id: &'a str,
-        test_runner: &'a TestRunner,
-    ) -> BoxFuture<'a, Result<Option<Entity>>> {
-        async move {
-            let ce = test_runner.get_client_encryption(id).await;
-            let entity = match ce.add_key_alt_name(&self.id, &self.key_alt_name).await? {
-                Some(key) => Entity::Bson(Bson::Document(key.to_document()?)),
-                None => Entity::None,
-            };
-            Ok(Some(entity))
-        }
-        .boxed()
-    }
-}
-
-#[cfg(feature = "csfle")]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub(super) struct CreateDataKey {
-    kms_provider: mongocrypt::ctx::KmsProvider,
-    opts: Option<crate::client_encryption::DataKeyOptions>,
-}
-
-#[cfg(feature = "csfle")]
-impl TestOperation for CreateDataKey {
-    fn execute_entity_operation<'a>(
-        &'a self,
-        id: &'a str,
-        test_runner: &'a TestRunner,
-    ) -> BoxFuture<'a, Result<Option<Entity>>> {
-        async move {
-            let ce = test_runner.get_client_encryption(id).await;
-            let key = ce
-                .create_data_key(&self.kms_provider, self.opts.clone())
-                .await?;
-            Ok(Some(Entity::Bson(Bson::Binary(key))))
-        }
-        .boxed()
-    }
-}
-
-#[cfg(feature = "csfle")]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub(super) struct GetKeys {}
-
-#[cfg(feature = "csfle")]
-impl TestOperation for GetKeys {
-    fn execute_entity_operation<'a>(
-        &'a self,
-        id: &'a str,
-        test_runner: &'a TestRunner,
-    ) -> BoxFuture<'a, Result<Option<Entity>>> {
-        async move {
-            let ce = test_runner.get_client_encryption(id).await;
-            let mut cursor = ce.get_keys().await?;
-            let mut keys = vec![];
-            while let Some(key) = cursor.try_next().await? {
-                keys.push(Bson::Document(key.to_document()?));
-            }
-            Ok(Some(Entity::Bson(Bson::Array(keys))))
-        }
-        .boxed()
-    }
-}
-
-#[cfg(feature = "csfle")]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub(super) struct RemoveKeyAltName {
-    id: bson::Binary,
-    key_alt_name: String,
-}
-
-#[cfg(feature = "csfle")]
-impl TestOperation for RemoveKeyAltName {
-    fn execute_entity_operation<'a>(
-        &'a self,
-        id: &'a str,
-        test_runner: &'a TestRunner,
-    ) -> BoxFuture<'a, Result<Option<Entity>>> {
-        async move {
-            let ce = test_runner.get_client_encryption(id).await;
-            let entity = match ce.remove_key_alt_name(&self.id, &self.key_alt_name).await? {
-                Some(key) => Entity::Bson(Bson::Document(key.to_document()?)),
-                None => Entity::None,
-            };
-            Ok(Some(entity))
-        }
-        .boxed()
-    }
-}
-
 #[derive(Debug, Deserialize)]
 pub(super) struct UnimplementedOperation {
     _name: String,