π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
Prune low-value Rust tests
Manav Rathicab02d104cf8
diff --git a/rust/crates/accounts/src/auth/key_gen.rs b/rust/crates/accounts/src/auth/key_gen.rsindex a12e5d4dba..7a11083a2c 100644--- a/rust/crates/accounts/src/auth/key_gen.rs+++ b/rust/crates/accounts/src/auth/key_gen.rs@@ -163,47 +163,6 @@ mod tests {generate_keys_with_strength(password, KeyDerivationStrength::Interactive)}- #[test]- fn test_generate_keys() {- let result = generate_test_keys("test_password_123").unwrap();-- assert!(!result.key_attributes.kek_salt.is_empty());- assert!(!result.key_attributes.encrypted_key.is_empty());- assert!(!result.key_attributes.public_key.is_empty());- assert!(!result.private_key_attributes.key.is_empty());- assert!(!result.private_key_attributes.recovery_key.is_empty());- assert_eq!(result.login_key.len(), 16);-- let master_key = b64::decode(&result.private_key_attributes.key).unwrap();- assert_eq!(master_key.len(), 32);- assert_eq!(result.private_key_attributes.recovery_key.len(), 64);- }-- #[test]- fn test_generate_keys_can_decrypt_master_key() {- let result = generate_test_keys("my_secure_password").unwrap();-- let encrypted_key = b64::decode(&result.key_attributes.encrypted_key).unwrap();- let nonce = b64::decode(&result.key_attributes.key_decryption_nonce).unwrap();- let decrypted_master = decrypt_raw(&encrypted_key, &nonce, &result.key_encryption_key);-- let original_master = b64::decode(&result.private_key_attributes.key).unwrap();- assert_eq!(decrypted_master, original_master);- }-- #[test]- fn test_generate_keys_can_decrypt_secret_key() {- let result = generate_test_keys("password").unwrap();- let master_key = b64::decode(&result.private_key_attributes.key).unwrap();-- let encrypted = b64::decode(&result.key_attributes.encrypted_secret_key).unwrap();- let nonce = b64::decode(&result.key_attributes.secret_key_decryption_nonce).unwrap();- let decrypted = decrypt_raw(&encrypted, &nonce, &master_key);-- let original = b64::decode(&result.private_key_attributes.secret_key).unwrap();- assert_eq!(decrypted, original);- }-#[test]fn test_generate_keys_recovery_key_can_decrypt_master() {let result = generate_test_keys("password").unwrap();@@ -314,20 +273,4 @@ mod tests {);assert_eq!(decrypted_recovery, recovery_key);}-- #[test]- fn test_different_passwords_produce_different_keys() {- let result1 = generate_test_keys("password1").unwrap();- let result2 = generate_test_keys("password2").unwrap();-- assert_ne!(- result1.key_attributes.kek_salt,- result2.key_attributes.kek_salt- );- assert_ne!(- result1.private_key_attributes.key,- result2.private_key_attributes.key- );- assert_ne!(result1.login_key, result2.login_key);- }}diff --git a/rust/crates/accounts/src/auth/srp.rs b/rust/crates/accounts/src/auth/srp.rsindex ff4a72ba90..f63b40279b 100644--- a/rust/crates/accounts/src/auth/srp.rs+++ b/rust/crates/accounts/src/auth/srp.rs@@ -149,19 +149,6 @@ impl Drop for SrpSession {mod tests {use super::*;- #[test]- fn test_srp_session_creation() {- let srp_user_id = "test-user-id";- let srp_salt = [0u8; 16];- let login_key = [0u8; 16];-- let session = SrpSession::new(srp_user_id, &srp_salt, &login_key).unwrap();-- let a = session.public_a();- assert!(!a.is_empty());- assert!(a.len() >= SRP_N_BYTES);- }-#[test]fn test_public_a_padding() {let a_public = vec![0xAB, 0xCD];diff --git a/rust/crates/core/src/crypto/argon.rs b/rust/crates/core/src/crypto/argon.rsindex 7d30842bb1..a9a6e62419 100644--- a/rust/crates/core/src/crypto/argon.rs+++ b/rust/crates/core/src/crypto/argon.rs@@ -192,104 +192,6 @@ mod tests {Salt::from_bytes([0x42u8; Salt::BYTES])}- #[test]- fn test_derive_key() {- let password = "correct horse battery staple";- let salt = Salt::generate();-- derive_key(password, &salt, Params::INTERACTIVE).unwrap();- }-- #[test]- fn test_derive_key_deterministic() {- let password = "test password";- let salt = test_salt();-- let key1 = derive_key(password, &salt, Params::INTERACTIVE).unwrap();- let key2 = derive_key(password, &salt, Params::INTERACTIVE).unwrap();-- assert_eq!(key1, key2);- }-- #[test]- fn test_different_passwords() {- let salt = test_salt();-- let key1 = derive_key("password1", &salt, Params::INTERACTIVE).unwrap();- let key2 = derive_key("password2", &salt, Params::INTERACTIVE).unwrap();-- assert_ne!(key1, key2);- }-- #[test]- fn test_different_salts() {- let password = "same password";- let salt1 = test_salt();- let salt2 = Salt::from_bytes([0x43u8; Salt::BYTES]);-- let key1 = derive_key(password, &salt1, Params::INTERACTIVE).unwrap();- let key2 = derive_key(password, &salt2, Params::INTERACTIVE).unwrap();-- assert_ne!(key1, key2);- }-- #[test]- fn test_different_params() {- let password = "test";- let salt = test_salt();-- let base = derive_key(password, &salt, Params::INTERACTIVE).unwrap();- let more_mem = derive_key(- password,- &salt,- Params {- mem_limit: Params::MODERATE.mem_limit,- ops_limit: Params::INTERACTIVE.ops_limit,- },- )- .unwrap();- let more_ops = derive_key(- password,- &salt,- Params {- mem_limit: Params::INTERACTIVE.mem_limit,- ops_limit: Params::MODERATE.ops_limit,- },- )- .unwrap();-- assert_ne!(base, more_mem);- assert_ne!(base, more_ops);- }-- #[test]- fn test_derive_interactive_key() {- let result = derive_interactive_key("interactive test").unwrap();- assert_eq!(result.params, Params::INTERACTIVE);- }-- #[test]- fn test_derive_moderate_key() {- let result = derive_moderate_key("moderate test").unwrap();- assert_eq!(result.params, Params::MODERATE);- }-- #[test]- #[ignore] // Slow: uses high memory/ops settings- fn test_derive_sensitive_key() {- let result = derive_sensitive_key("sensitive test").unwrap();-- let desired_strength =- u64::from(Params::SENSITIVE.mem_limit) * u64::from(Params::SENSITIVE.ops_limit);- assert_eq!(- u64::from(result.params.mem_limit) * u64::from(result.params.ops_limit),- desired_strength- );- assert!(result.params.mem_limit <= Params::MODERATE.mem_limit);- assert!(result.params.ops_limit >= Params::SENSITIVE.ops_limit);- assert!(result.params.mem_limit >= MEMLIMIT_SENSITIVE_MIN);- }-#[test]fn test_sensitive_policy_matches_existing_client_bounds() {let desired_strength =diff --git a/rust/crates/core/src/crypto/blob.rs b/rust/crates/core/src/crypto/blob.rsindex 5a86eabc6a..1e00cf303f 100644--- a/rust/crates/core/src/crypto/blob.rs+++ b/rust/crates/core/src/crypto/blob.rs@@ -143,15 +143,6 @@ mod tests {assert_eq!(decrypted, b"partial");}- #[test]- fn test_encrypt_decrypt_large() {- let key = Key::generate();- let plaintext = vec![0x42u8; 1024 * 1024];-- let encrypted = encrypt(&plaintext, &key).unwrap();- assert_eq!(encrypted.decrypt(&key).unwrap(), plaintext);- }-#[test]fn test_encrypt_decrypt_combined() {let key = Key::generate();diff --git a/rust/crates/core/src/crypto/hash.rs b/rust/crates/core/src/crypto/hash.rsindex bf3b816367..681baf8dc5 100644--- a/rust/crates/core/src/crypto/hash.rs+++ b/rust/crates/core/src/crypto/hash.rs@@ -171,18 +171,6 @@ mod tests {assert_ne!(hash1, hash2);}- #[test]- fn test_keyed_hash_different_keys() {- let data = b"Same data";- let key1 = vec![0x42u8; 32];- let key2 = vec![0x43u8; 32];-- let hash1 = hash(data, Some(64), Some(&key1)).unwrap();- let hash2 = hash(data, Some(64), Some(&key2)).unwrap();-- assert_ne!(hash1, hash2);- }-#[test]fn test_empty_key_same_as_no_key() {let data = b"Test";@@ -221,28 +209,4 @@ mod tests {let hash = hash_default(data).unwrap();assert_eq!(hash.len(), HASH_BYTES);}-- #[test]- fn test_large_data() {- let data = vec![0x42u8; 1024 * 1024];- let hash = hash_default(&data).unwrap();- assert_eq!(hash.len(), HASH_BYTES);- }-- #[test]- fn test_avalanche_effect() {- let data1 = b"Test";- let data2 = b"Test ";-- let hash1 = hash_default(data1).unwrap();- let hash2 = hash_default(data2).unwrap();-- let diff_count = hash1- .iter()- .zip(hash2.iter())- .filter(|(a, b)| a != b)- .count();-- assert!(diff_count > 15);- }}diff --git a/rust/crates/core/src/crypto/kdf.rs b/rust/crates/core/src/crypto/kdf.rsindex dc8f58487d..a82eebac8b 100644--- a/rust/crates/core/src/crypto/kdf.rs+++ b/rust/crates/core/src/crypto/kdf.rs@@ -67,12 +67,6 @@ mod tests {Key::from_bytes([0x42u8; Key::BYTES])}- #[test]- fn test_derive_subkey() {- let subkey = derive_subkey(&test_key(), 32, 1, b"testctx0").unwrap();- assert_eq!(subkey.len(), 32);- }-#[test]fn test_derive_subkey_deterministic() {let subkey1 = derive_subkey(&test_key(), 32, 1, b"context0").unwrap();@@ -110,13 +104,6 @@ mod tests {}}- #[test]- fn test_derive_login_key() {- let login_key = derive_login_key(&test_key());- assert_eq!(login_key.len(), 16);- assert_eq!(login_key, derive_login_key(&test_key()));- }-#[test]fn test_login_key_is_subkey() {let login_key = derive_login_key(&test_key());diff --git a/rust/crates/core/src/crypto/sealed.rs b/rust/crates/core/src/crypto/sealed.rsindex 09025d9fc1..6231457450 100644--- a/rust/crates/core/src/crypto/sealed.rs+++ b/rust/crates/core/src/crypto/sealed.rs@@ -249,17 +249,6 @@ mod tests {assert_eq!(sealed.len(), SEAL_OVERHEAD);}- #[test]- fn test_large_plaintext() {- let (pk, sk) = generate_keypair();- let plaintext = vec![0x42u8; 1024 * 1024];-- let sealed = seal(&plaintext, &pk).unwrap();- let opened = open(&sealed, &pk, &sk).unwrap();-- assert_eq!(opened, plaintext);- }-#[test]fn test_seal_rejects_small_order_point() {let zero_pk = PublicKey::from_bytes([0u8; 32]);diff --git a/rust/crates/core/src/crypto/secret.rs b/rust/crates/core/src/crypto/secret.rsindex 12393b8a41..d6437053ac 100644--- a/rust/crates/core/src/crypto/secret.rs+++ b/rust/crates/core/src/crypto/secret.rs@@ -152,13 +152,6 @@ mod tests {assert!(vec.iter().all(|&b| b == 0xCD));}- #[test]- fn test_secret_vec_into_vec_leaves_empty_inner() {- let secret = SecretVec::new(vec![0xEFu8; 16]);- let vec = secret.into_vec();- assert_eq!(vec.len(), 16);- }-#[test]fn test_secret_vec_debug_redacts() {let secret = SecretVec::new(vec![42u8; 16]);@@ -166,12 +159,4 @@ mod tests {assert_eq!(debug, "[REDACTED]");assert!(!debug.contains("42"));}-- #[test]- fn test_secret_vec_deref_and_len() {- let secret = SecretVec::new(vec![1, 2, 3]);- assert_eq!(secret.len(), 3);- assert_eq!(&*secret, &[1, 2, 3]);- assert_eq!(secret.as_ref(), &[1, 2, 3]);- }}diff --git a/rust/crates/core/src/crypto/secretbox.rs b/rust/crates/core/src/crypto/secretbox.rsindex e1521c493d..fe95015842 100644--- a/rust/crates/core/src/crypto/secretbox.rs+++ b/rust/crates/core/src/crypto/secretbox.rs@@ -87,32 +87,6 @@ pub fn decrypt_combined(data: &[u8], key: &Key) -> Result<Vec<u8>> {mod tests {use super::*;- #[test]- fn test_encrypt_decrypt() {- let key = Key::generate();- let plaintext = b"Hello, World!";-- let encrypted = encrypt(plaintext, &key);- assert_eq!(encrypted.encrypted_data.len(), MAC_BYTES + plaintext.len());-- let decrypted = encrypted.decrypt(&key).unwrap();- assert_eq!(decrypted, plaintext);- }-- #[test]- fn test_encrypt_with_nonce_is_deterministic() {- let key = Key::generate();- let nonce = Nonce::generate();- let plaintext = b"Deterministic test";-- let encrypted1 = encrypt_with_nonce(plaintext, &nonce, &key);- let encrypted2 = encrypt_with_nonce(plaintext, &nonce, &key);- assert_eq!(encrypted1, encrypted2);-- let decrypted = decrypt(&encrypted1, &nonce, &key).unwrap();- assert_eq!(decrypted, plaintext);- }-#[test]fn test_nacl_vector() {// NaCl's tests/secretbox.c vector.@@ -222,13 +196,4 @@ mod tests {let combined = encrypt_combined(b"", &key);assert_eq!(decrypt_combined(&combined, &key).unwrap(), b"");}-- #[test]- fn test_large_plaintext() {- let key = Key::generate();- let plaintext = vec![0x42u8; 1024 * 1024];-- let encrypted = encrypt(&plaintext, &key);- assert_eq!(encrypted.decrypt(&key).unwrap(), plaintext);- }}diff --git a/rust/crates/core/src/crypto/types.rs b/rust/crates/core/src/crypto/types.rsindex 0285cc318b..ab7398e1d8 100644--- a/rust/crates/core/src/crypto/types.rs+++ b/rust/crates/core/src/crypto/types.rs@@ -227,13 +227,6 @@ pub(crate) fn fill_random(buf: &mut [u8]) {mod tests {use super::*;- #[test]- fn test_key_generate() {- let key = Key::generate();- let key2 = Key::generate();- assert_ne!(key, key2);- }-#[test]fn test_key_roundtrips() {let key = Key::generate();@@ -259,12 +252,6 @@ mod tests {assert!(!debug.contains("42"));}- #[test]- fn test_nonce_salt_generate() {- assert_ne!(Nonce::generate(), Nonce::generate());- assert_ne!(Salt::generate(), Salt::generate());- }-#[test]fn test_non_secret_types_reject_wrong_length() {assert!(Nonce::try_from_slice(&[0u8; 12]).is_err());@@ -273,15 +260,6 @@ mod tests {assert!(PublicKey::try_from_slice(&[0u8; 31]).is_err());}- #[test]- fn test_secret_key_public_key_is_deterministic() {- let sk = SecretKey::generate();- assert_eq!(sk.public_key(), sk.public_key());-- let sk2 = SecretKey::generate();- assert_ne!(sk.public_key(), sk2.public_key());- }-#[test]fn test_secret_key_from_seed_is_deterministic() {let seed = [7u8; 32];@@ -290,11 +268,4 @@ mod tests {assert_eq!(sk1, sk2);assert_eq!(sk1.public_key(), sk2.public_key());}-- #[test]- fn test_random_bytes() {- let bytes = random_bytes(16);- assert_eq!(bytes.len(), 16);- assert_ne!(bytes, random_bytes(16));- }}diff --git a/rust/crates/ensu/src/model/mod.rs b/rust/crates/ensu/src/model/mod.rsindex 385cbe9ab0..27b80eb8e5 100644--- a/rust/crates/ensu/src/model/mod.rs+++ b/rust/crates/ensu/src/model/mod.rs@@ -251,21 +251,4 @@ mod tests {assert_eq!(desktop_llm_asset("").unwrap(), desktop_default);assert_eq!(desktop_llm_asset("no-such-model").unwrap(), desktop_default);}-- #[test]- fn all_catalog_presets_produce_valid_assets() {- for preset in crate::config::llm_catalog() {- llm_asset(&preset).expect("catalog preset");- }- }-- #[test]- fn knowledge_embedding_asset_is_checksum_backed() {- let store = AssetStore::new(std::env::temp_dir().join("ensu-assets-test"));- let asset = knowledge_embedding_model_asset();- assert_eq!(- store.file_path(&asset, "model.gguf"),- Some(store.asset_dir(&asset).join("model.gguf"))- );- }}diff --git a/rust/crates/ml/src/scan/geometry.rs b/rust/crates/ml/src/scan/geometry.rsindex 2ee45b1910..23a3ce7316 100644--- a/rust/crates/ml/src/scan/geometry.rs+++ b/rust/crates/ml/src/scan/geometry.rs@@ -128,7 +128,7 @@ pub(crate) fn create_quad(vertices: &[Point]) -> Quad {#[cfg(test)]mod tests {- use super::{ImageSize, Point, Quad, create_quad, norm};+ use super::{Point, Quad, create_quad};fn assert_close(a: f64, b: f64, eps: f64) {assert!((a - b).abs() <= eps, "expected {a} ~= {b} (eps {eps})");@@ -176,16 +176,4 @@ mod tests {assert_close(scaled.top_right.x, 512.0, 1e-9);assert_close(scaled.bottom_right.y, 512.0, 1e-9);}-- #[test]- fn norm_matches_hypot() {- assert_close(norm(Point::new(0.0, 0.0), Point::new(3.0, 4.0)), 5.0, 1e-12);- }-- #[test]- fn image_size_keeps_doubles() {- let size = ImageSize::new(1024.0, 768.0);- assert_close(size.width, 1024.0, 0.0);- assert_close(size.height, 768.0, 0.0);- }}