RUST-2199 Remove all serverless testing logic (#1415)

Author: abr-egn

.evergreen/config.yml

@@ -267,17 +267,6 @@ buildvariants:
     tasks:
       - name: test-x509-auth
 
-  # - name: serverless
-  #   display_name: "Serverless"
-  #   run_on:
-  #     - rhel80-small
-  #   expansions:
-  #     LIBMONGOCRYPT_OS: rhel-80-64-bit
-  #     AUTH: auth
-  #     SSL: ssl
-  #   tasks:
-  #     - serverless-task-group
-
   - name: oidc-linux
     display_name: "OIDC Linux"
     patchable: true
@@ -407,43 +396,6 @@ buildvariants:
 # Task Groups #
 ###############
 task_groups:
-  - name: serverless-task-group
-    setup_group_can_fail_task: true
-    setup_group_timeout_secs: 1800 # 30 minutes
-    setup_group:
-      - func: "fetch source"
-      - func: "create expansions"
-      - func: "prepare resources"
-      - func: "windows fix"
-      - func: "fix absolute paths"
-      - func: "init test-results"
-      - func: "make files executable"
-      - func: "install rust"
-      - func: "install junit dependencies"
-      - command: shell.exec
-        params:
-          shell: "bash"
-          script: |
-            ${PREPARE_SHELL}
-            bash ${DRIVERS_TOOLS}/.evergreen/serverless/setup-secrets.sh
-            bash ${DRIVERS_TOOLS}/.evergreen/serverless/create-instance.sh
-      - command: expansions.update
-        params:
-          file: serverless-expansion.yml
-    teardown_group:
-      - command: shell.exec
-        params:
-          script: |
-            ${PREPARE_SHELL}
-            bash ${DRIVERS_TOOLS}/.evergreen/serverless/delete-instance.sh
-      - func: "upload test results"
-      - func: "upload-mo-artifacts"
-      - func: "cleanup"
-
-    tasks:
-      - "test-serverless"
-      - "test-in-use-encryption-serverless"
-
   - name: azure-kms-task-group
     setup_group_can_fail_task: true
     setup_group_timeout_secs: 1800 # 30 minutes
@@ -1012,10 +964,6 @@ tasks:
           TOPOLOGY: server
       - func: "run x509 tests"
 
-  - name: test-serverless
-    commands:
-      - func: "run serverless tests"
-
   - name: test-tokio-sync
     tags: [sync]
     commands:
@@ -1112,18 +1060,6 @@ tasks:
       - func: "start csfle servers"
       - func: "run csfle tests"
 
-  - name: test-in-use-encryption-serverless
-    commands:
-      - command: expansions.update
-        params:
-          file: src/expansion.yml
-      - command: expansions.update
-        params:
-          file: serverless-expansion.yml
-      - func: "install libmongocrypt"
-      - func: "start csfle servers"
-      - func: "run csfle serverless tests"
-
   - name: test-load-balancer-5.0
     tags: [load-balancer]
     commands:
@@ -1578,23 +1514,6 @@ functions:
           - PROJECT_DIRECTORY
           - MONGODB_URI
 
-  "run serverless tests":
-    - command: shell.exec
-      type: test
-      params:
-        working_dir: src
-        shell: bash
-        include_expansions_in_env:
-          - SERVERLESS_ATLAS_USER
-          - SERVERLESS_ATLAS_PASSWORD
-        script: |
-          ${PREPARE_SHELL}
-
-          export SINGLE_MONGOS_LB_URI=${SERVERLESS_URI}
-          . .evergreen/generate-uri.sh
-
-          .evergreen/run-serverless-tests.sh
-
   "run atlas tests":
     - command: ec2.assume_role
       params:
@@ -1670,35 +1589,6 @@ functions:
           - DISABLE_CRYPT_SHARED
           - AZURE_IMDS_MOCK_PORT
 
-  "run csfle serverless tests":
-    - command: shell.exec
-      type: test
-      params:
-        working_dir: src
-        shell: bash
-        include_expansions_in_env:
-          - DRIVERS_TOOLS
-          - PROJECT_DIRECTORY
-          - MONGODB_URI
-          - MONGOCRYPT_LIB_DIR
-          - OPENSSL
-          - OS
-          - LD_LIBRARY_PATH
-          - AWS_ACCESS_KEY_ID
-          - AWS_SECRET_ACCESS_KEY
-          - CSFLE_LOCAL_KEY
-          - CRYPT_SHARED_LIB_PATH
-          - DISABLE_CRYPT_SHARED
-          - AZURE_IMDS_MOCK_PORT
-          - SERVERLESS_ATLAS_USER
-          - SERVERLESS_ATLAS_PASSWORD
-        script: |
-          export SINGLE_MONGOS_LB_URI=${SERVERLESS_URI}
-          . .evergreen/generate-uri.sh
-          export SERVERLESS=serverless
-
-          .evergreen/run-csfle-tests.sh
-
   "build and upload gcp kms test":
     - command: shell.exec
       params:

.evergreen/run-serverless-tests.sh

@@ -279,18 +279,12 @@ pub(crate) static SERVER_API: Lazy<Option<ServerApi>> =
         }),
         _ => None,
     });
-pub(crate) static SERVERLESS: Lazy<bool> =
-    Lazy::new(|| matches!(std::env::var("SERVERLESS"), Ok(s) if s == "serverless"));
 pub(crate) static LOAD_BALANCED_SINGLE_URI: Lazy<Option<String>> =
     Lazy::new(|| std::env::var("SINGLE_MONGOS_LB_URI").ok());
 pub(crate) static LOAD_BALANCED_MULTIPLE_URI: Lazy<Option<String>> =
     Lazy::new(|| std::env::var("MULTI_MONGOS_LB_URI").ok());
 pub(crate) static OIDC_URI: Lazy<Option<String>> =
     Lazy::new(|| std::env::var("MONGODB_URI_SINGLE").ok());
-pub(crate) static SERVERLESS_ATLAS_USER: Lazy<Option<String>> =
-    Lazy::new(|| std::env::var("SERVERLESS_ATLAS_USER").ok());
-pub(crate) static SERVERLESS_ATLAS_PASSWORD: Lazy<Option<String>> =
-    Lazy::new(|| std::env::var("SERVERLESS_ATLAS_PASSWORD").ok());
 
 // conditional definitions do not work within the lazy_static! macro, so this
 // needs to be defined separately.
@@ -322,15 +316,6 @@ pub(crate) fn update_options_for_testing(options: &mut ClientOptions) {
     ))]
     set_compressor(options);
 
-    if options.credential.is_none() && SERVERLESS_ATLAS_USER.is_some() {
-        options.credential = Some(
-            Credential::builder()
-                .username(SERVERLESS_ATLAS_USER.clone())
-                .password(SERVERLESS_ATLAS_PASSWORD.clone())
-                .build(),
-        );
-    }
-
     if let Some(ref mut credential) = options.credential {
         if credential.mechanism == Some(AuthMechanism::MongoDbOidc)
             && credential

src/test.rs

@@ -7,7 +7,7 @@ use reqwest::{Certificate, Client as HttpClient};
 
 use crate::{
     client_encryption::{AwsMasterKey, AzureMasterKey, ClientEncryption, GcpMasterKey},
-    test::{get_client_options, log_uncaptured, SERVERLESS},
+    test::get_client_options,
     Client,
     Namespace,
 };
@@ -16,11 +16,6 @@ use super::{AWS_KMS, AZURE_KMS, CSFLE_TLS_CERT_DIR, GCP_KMS};
 
 #[tokio::test]
 async fn kms_retry() {
-    if *SERVERLESS {
-        log_uncaptured("skipping kms_retry on serverless");
-        return;
-    }
-
     let endpoint = "127.0.0.1:9003";
 
     let mut certificate_file_path = PathBuf::from(&*CSFLE_TLS_CERT_DIR);

src/test/csfle/kms_retry.rs

@@ -7,20 +7,12 @@ use crate::{
     bson::doc,
     options::{CreateCollectionOptions, CursorType, FindOptions},
     runtime,
-    test::{log_uncaptured, SERVERLESS},
     Client,
 };
 
 #[tokio::test]
 #[function_name::named]
 async fn tailable_cursor() {
-    if *SERVERLESS {
-        log_uncaptured(
-            "skipping cursor::tailable_cursor; serverless does not support capped collections",
-        );
-        return;
-    }
-
     let client = Client::for_test().await;
     let coll = client
         .create_fresh_collection(

src/test/cursor.rs

@@ -41,7 +41,7 @@ pub(crate) use self::{
     unified_runner::{merge_uri_options, ExpectedEventType, Topology},
     v2_runner::{operation::Operation, test_file::RunOn},
 };
-use crate::{bson::Bson, test::SERVERLESS};
+use crate::bson::Bson;
 
 use super::log_uncaptured;
 
@@ -142,10 +142,6 @@ pub(crate) enum Serverless {
 
 impl Serverless {
     pub(crate) fn can_run(&self) -> bool {
-        match self {
-            Self::Forbid if *SERVERLESS => false,
-            Self::Require if !*SERVERLESS => false,
-            _ => true,
-        }
+        *self != Self::Require
     }
 }

src/test/spec.rs

@@ -1,11 +1,6 @@
 use crate::{
     bson::doc,
-    test::{
-        log_uncaptured,
-        server_version_lt,
-        spec::unified_runner::run_unified_tests,
-        SERVERLESS,
-    },
+    test::{log_uncaptured, server_version_lt, spec::unified_runner::run_unified_tests},
     Client,
 };
 
@@ -37,17 +32,13 @@ async fn run_unified() {
         "findOneAndUpdate-errorResponse.json",
     ];
 
-    let mut skipped_tests = vec![
+    let skipped_tests = vec![
         // Unacknowledged write; see above.
         "Unacknowledged write using dollar-prefixed or dotted keys may be silently rejected on \
          pre-5.0 server",
         "Requesting unacknowledged write with verboseResults is a client-side error",
         "Requesting unacknowledged write with ordered is a client-side error",
     ];
-    // TODO: remove this manual skip when this test is fixed to skip on serverless
-    if *SERVERLESS {
-        skipped_tests.push("inserting _id with type null via clientBulkWrite");
-    }
 
     run_unified_tests(&["crud", "unified"])
         .skip_files(&skipped_files)
@@ -74,7 +65,7 @@ async fn generated_id_first_field() {
     let (key, _) = insert_document.iter().next().unwrap();
     assert_eq!(key, "_id");
 
-    if server_version_lt(8, 0).await || *SERVERLESS {
+    if server_version_lt(8, 0).await {
         log_uncaptured("skipping bulk write test in generated_id_first_field");
         return;
     }

src/test/spec/crud.rs

@@ -28,7 +28,6 @@ use crate::{
         DEFAULT_URI,
         LOAD_BALANCED_MULTIPLE_URI,
         LOAD_BALANCED_SINGLE_URI,
-        SERVERLESS,
         SERVER_API,
     },
     Client,
@@ -471,8 +470,7 @@ impl TestRunner {
                     let server_api = client.server_api.clone().or_else(|| SERVER_API.clone());
 
                     let given_uri = if get_client_options().await.load_balanced.unwrap_or(false) {
-                        // for serverless testing, ignore use_multiple_mongoses.
-                        if client.use_multiple_mongoses() && !*SERVERLESS {
+                        if client.use_multiple_mongoses() {
                             LOAD_BALANCED_MULTIPLE_URI.as_ref().expect(
                                 "Test requires URI for load balancer fronting multiple servers",
                             )

src/test/spec/unified_runner/test_runner.rs

@@ -30,7 +30,6 @@ use crate::{
         },
         EventClient,
         TestClient,
-        SERVERLESS,
     },
     Client,
     ClientSession,
@@ -318,7 +317,7 @@ impl crate::test::util::TestClientBuilder {
 
         let default_options = if is_load_balanced {
             // for serverless testing, ignore use_multiple_mongoses.
-            let uri = if use_multiple_mongoses && !*SERVERLESS {
+            let uri = if use_multiple_mongoses {
                 crate::test::LOAD_BALANCED_MULTIPLE_URI
                     .as_ref()
                     .expect("MULTI_MONGOS_LB_URI is required")
@@ -520,21 +519,17 @@ async fn run_v2_test(path: std::path::PathBuf, test_file: TestFile) {
             continue;
         }
 
-        // `killAllSessions` isn't supported on serverless.
-        // TODO CLOUDP-84298 remove this conditional.
-        if !*SERVERLESS {
-            match file_ctx
-                .internal_client
-                .database("admin")
-                .run_command(doc! { "killAllSessions": [] })
-                .await
-            {
-                Ok(_) => {}
-                Err(err) => match err.sdam_code() {
-                    Some(11601) => {}
-                    _ => panic!("{}: killAllSessions failed", test.description),
-                },
-            }
+        match file_ctx
+            .internal_client
+            .database("admin")
+            .run_command(doc! { "killAllSessions": [] })
+            .await
+        {
+            Ok(_) => {}
+            Err(err) => match err.sdam_code() {
+                Some(11601) => {}
+                _ => panic!("{}: killAllSessions failed", test.description),
+            },
         }
 
         #[cfg(feature = "in-use-encryption")]