Fix flaky tests (#511)

* chore: use a proper tempdir like the other tests

* chore: use `BTreeSet` to ensure `Role`s are in order

* chore: make `naive_mul` a little less naive so tests run at tolerable speed

* chore: use multiple threads to speed up dkg test

* chore:formatting

* chore: use multi threaded tokio test for tests involving multiple parties

* chore: gate heavy tests in threshold-experimental under `slow_tests`

* Attempt to fix another set of flaky test

* Revert "Attempt to fix another set of flaky test"

This reverts commit c61a37a.

Author: dvdplm

core/service/src/client/tests/threshold/custodian_backup_tests.rs

@@ -73,7 +73,8 @@ async fn auto_update_backup(amount_custodians: usize, threshold: u32) {
     ))
     .unwrap();
 
-    let test_path = None;
+    let temp_dir = tempfile::tempdir().unwrap();
+    let test_path = Some(temp_dir.path());
     let dkg_param: WrappedDKGParams = FheParameter::Test.into();
     tokio::time::sleep(tokio::time::Duration::from_millis(TIME_TO_SLEEP_MS)).await;
     let (kms_servers, kms_clients, mut internal_client) = threshold_handles_custodian_backup(

core/threshold-experimental/src/algebra/ntt.rs

@@ -226,27 +226,27 @@ mod tests {
 
     fn naive_mul<T>(a: &[T], b: &[T], n: usize) -> Vec<T>
     where
-        T: Zero + Copy,
+        T: Zero + Copy + Send + Sync,
         T: Add<Output = T>,
         T: Mul<Output = T>,
         T: Sub<Output = T>,
     {
-        let mut c = Vec::with_capacity(n);
-        for _ in 0..n {
-            c.push(T::ZERO);
-        }
+        use rayon::prelude::*;
 
-        for i in 0..n {
-            for j in 0..n {
-                let w = c[(i + j) % n];
-                if (i + j) < n {
-                    c[i + j] = w + a[i] * b[j];
-                } else {
-                    c[(i + j) % n] = w - a[i] * b[j]
+        (0..n)
+            .into_par_iter()
+            .map(|k| {
+                let mut pos = T::ZERO;
+                let mut neg = T::ZERO;
+                for j in 0..=k {
+                    pos = pos + a[k - j] * b[j];
                 }
-            }
-        }
-        c
+                for j in (k + 1)..n {
+                    neg = neg + a[k + n - j] * b[j];
+                }
+                pos - neg
+            })
+            .collect()
     }
 
     #[test]

core/threshold-experimental/src/bgv/dkg.rs

@@ -250,7 +250,7 @@ mod tests {
         assert_eq!(plaintext, plaintext_vec);
     }
 
-    #[tokio::test]
+    #[tokio::test(flavor = "multi_thread")]
     async fn test_dkg_dummy_preproc() {
         let parties = 5;
         let threshold = 1;
@@ -286,7 +286,7 @@ mod tests {
         test_dkg(&mut results, PLAINTEXT_MODULUS.get().0);
     }
 
-    #[tokio::test]
+    #[tokio::test(flavor = "multi_thread")]
     async fn test_dkg_with_offline() {
         let parties = 5;
         let threshold = 1;

core/threshold-experimental/src/bgv/endpoints.rs

@@ -13,7 +13,7 @@ use algebra::sharing::share::Share;
 use hashing::serialize_hash_element;
 use itertools::Itertools;
 use rand::SeedableRng;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 use threshold_execution::runtime::sessions::{
     base_session::BaseSession,
@@ -64,8 +64,13 @@ pub fn threshold_decrypt(
         let net = Arc::clone(&runtime.user_nets[role.one_based() - 1]);
         let threshold = runtime.threshold;
 
-        let session_params =
-            SessionParameters::new(threshold, session_id, role, runtime.roles.clone()).unwrap();
+        let session_params = SessionParameters::new(
+            threshold,
+            session_id,
+            role,
+            runtime.roles.iter().copied().collect::<HashSet<_>>(),
+        )
+        .unwrap();
         let base_session = BaseSession::new(session_params, net, AesRng::from_entropy()).unwrap();
 
         let sk_shares = private_keys[&role]

core/threshold-experimental/src/bgv/runtime.rs

@@ -1,4 +1,4 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::{BTreeSet, HashMap, HashSet};
 use std::sync::Arc;
 use tokio::time::Duration;
 
@@ -9,7 +9,7 @@ use threshold_types::role::Role;
 pub struct BGVTestRuntime {
     pub threshold: u8,
     pub user_nets: Vec<Arc<LocalNetworking<Role>>>,
-    pub roles: HashSet<Role>,
+    pub roles: BTreeSet<Role>,
 }
 
 impl BGVTestRuntime {
@@ -20,7 +20,8 @@ impl BGVTestRuntime {
         delayed_map: Option<HashMap<Role, Duration>>,
     ) -> Self {
         let net_producer = LocalNetworkingProducer::from_roles(&roles);
-        let user_nets: Vec<Arc<LocalNetworking<Role>>> = roles
+        let sorted_roles: BTreeSet<Role> = roles.into_iter().collect();
+        let user_nets: Vec<Arc<LocalNetworking<Role>>> = sorted_roles
             .iter()
             .map(|role| {
                 let delay = if let Some(delayed_map) = &delayed_map {
@@ -36,7 +37,7 @@ impl BGVTestRuntime {
         BGVTestRuntime {
             threshold,
             user_nets,
-            roles,
+            roles: sorted_roles,
         }
     }
 }

core/threshold-experimental/src/gen_bits_odd.rs

@@ -159,7 +159,7 @@ mod tests {
 
     use super::*;
 
-    #[tokio::test]
+    #[tokio::test(flavor = "multi_thread")]
     async fn test_bitgen() {
         let parties = 4;
         let threshold = 1;