RUST-1012 remove Clone impl from ClientSession (#450)

Author: abr-egn

src/client/session/mod.rs

@@ -99,7 +99,7 @@ lazy_static! {
 ///     }
 /// }
 /// ```
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct ClientSession {
     cluster_time: Option<ClusterTime>,
     server_session: ServerSession,

src/test/spec/unified_runner/entity.rs

@@ -14,7 +14,7 @@ use crate::{
     Database,
 };
 
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub enum Entity {
     Client(ClientEntity),
     Database(Database),
@@ -33,7 +33,7 @@ pub struct ClientEntity {
     observe_sensitive_commands: bool,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct SessionEntity {
     pub lsid: Document,
     pub client_session: Option<Box<ClientSession>>,

src/test/spec/unified_runner/mod.rs

@@ -12,7 +12,7 @@ use semver::Version;
 use tokio::sync::RwLockWriteGuard;
 
 use crate::{
-    bson::{doc, Document},
+    bson::{doc, Bson, Document},
     options::{CollectionOptions, FindOptions, ReadConcern, ReadPreference, SelectionCriteria},
     test::{run_single_test, run_spec_test, LOCK},
     RUNTIME,
@@ -140,14 +140,26 @@ pub async fn run_unified_format_test(test_file: TestFile) {
                         .execute_entity_operation(id, &mut test_runner)
                         .await;
 
+                    // Precache the BSON result, if any, so that other entities can be saved without
+                    // cloning.
+                    #[derive(Debug)]
+                    enum ResultEntity {
+                        Bson(Bson),
+                        Other,
+                        None,
+                    }
+
+                    let bson_result = match &result {
+                        Ok(Some(Entity::Bson(bson))) => Ok(ResultEntity::Bson(bson.clone())),
+                        Ok(Some(_)) => Ok(ResultEntity::Other),
+                        Ok(None) => Ok(ResultEntity::None),
+                        Err(e) => Err(e.clone()),
+                    };
+
                     if let Some(ref id) = operation.save_result_as_entity {
-                        match &result {
+                        match result {
                             Ok(Some(entity)) => {
-                                if test_runner
-                                    .entities
-                                    .insert(id.clone(), entity.clone())
-                                    .is_some()
-                                {
+                                if test_runner.entities.insert(id.clone(), entity).is_some() {
                                     panic!("Entity with id {} already present in entity map", id);
                                 }
                             }
@@ -157,22 +169,19 @@ pub async fn run_unified_format_test(test_file: TestFile) {
                     }
 
                     if let Some(expect_error) = operation.expect_error {
-                        let error = result
+                        let error = bson_result
                             .expect_err(&format!("{} should return an error", operation.name));
                         expect_error.verify_result(error);
                     } else {
-                        let result = result.unwrap_or_else(|e| {
+                        let result = bson_result.unwrap_or_else(|e| {
                             panic!(
                                 "{} should succeed, but the following error: {}",
                                 operation.name, e
                             )
                         });
                         if let Some(ref expect_result) = operation.expect_result {
-                            let result = result.unwrap_or_else(|| {
-                                panic!("{} should return an entity", operation.name)
-                            });
                             match result {
-                                Entity::Bson(ref result) => {
+                                ResultEntity::Bson(ref result) => {
                                     assert!(
                                         results_match(
                                             Some(result),
@@ -185,10 +194,13 @@ pub async fn run_unified_format_test(test_file: TestFile) {
                                         result
                                     );
                                 }
-                                _ => panic!(
+                                ResultEntity::Other => panic!(
                                     "Incorrect entity type returned from {}, expected BSON",
                                     operation.name
                                 ),
+                                ResultEntity::None => {
+                                    panic!("{} should return an entity", operation.name)
+                                }
                             }
                         }
                     }

src/test/spec/unified_runner/operation.rs

@@ -35,6 +35,8 @@ use crate::{
     },
     selection_criteria::ReadPreference,
     test::FailPoint,
+    Collection,
+    Database,
     IndexModel,
     RUNTIME,
 };
@@ -566,10 +568,19 @@ impl TestOperation for Aggregate {
         async move {
             let result = match &self.session {
                 Some(session_id) => {
-                    let entity = test_runner.entities.get(id).unwrap().clone();
+                    enum AggregateEntity {
+                        Collection(Collection<Document>),
+                        Database(Database),
+                        Other(String),
+                    }
+                    let entity = match test_runner.entities.get(id).unwrap() {
+                        Entity::Collection(c) => AggregateEntity::Collection(c.clone()),
+                        Entity::Database(d) => AggregateEntity::Database(d.clone()),
+                        other => AggregateEntity::Other(format!("{:?}", other)),
+                    };
                     let session = test_runner.get_mut_session(session_id);
                     let mut cursor = match entity {
-                        Entity::Collection(collection) => {
+                        AggregateEntity::Collection(collection) => {
                             collection
                                 .aggregate_with_session(
                                     self.pipeline.clone(),
@@ -578,15 +589,17 @@ impl TestOperation for Aggregate {
                                 )
                                 .await?
                         }
-                        Entity::Database(db) => {
+                        AggregateEntity::Database(db) => {
                             db.aggregate_with_session(
                                 self.pipeline.clone(),
                                 self.options.clone(),
                                 session,
                             )
                             .await?
                         }
-                        other => panic!("Cannot execute aggregate on {:?}", &other),
+                        AggregateEntity::Other(debug) => {
+                            panic!("Cannot execute aggregate on {}", &debug)
+                        }
                     };
                     cursor
                         .stream(session)