Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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);
- }
}