filip/Stalwart
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Bump to Rust 2024

Browse Source
This commit is contained in:
mdecimus
2025-02-21 09:59:23 +01:00
parent b1d6e71715
commit 44f8ef29e1
92 changed files with 570 additions and 477 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
tests/src/imap/append.rs
View File

@@ -32,7 +32,7 @@ pub async fn test(imap: &mut ImapConnection, _imap_check: &mut ImapConnection, h
let mut expected_uid = 1;
for file_name in entries.into_iter().take(20) {
if file_name.extension().map_or(true, |e| e != "txt") {
if file_name.extension().is_none_or( |e| e != "txt") {
continue;
}
let raw_message = fs::read(&file_name).unwrap();

2
tests/src/imap/body_structure.rs
View File

@@ -21,7 +21,7 @@ fn body_structure() {
for file_name in fs::read_dir(resources_dir()).unwrap() {
let mut file_name = file_name.as_ref().unwrap().path();
if file_name.extension().map_or(true, |e| e != "txt") {
if file_name.extension().is_none_or( |e| e != "txt") {
continue;
}

4
tests/src/jmap/email_get.rs
View File

@@ -7,7 +7,7 @@
use std::{fs, path::PathBuf};
use ::email::mailbox::INBOX_ID;
use jmap_client::email::{self, import::EmailImportResponse, Header, HeaderForm};
use jmap_client::email::{self, Header, HeaderForm, import::EmailImportResponse};
use jmap_proto::types::id::Id;
use mail_parser::HeaderName;
@@ -29,7 +29,7 @@ pub async fn test(params: &mut JMAPTest) {
for file_name in fs::read_dir(&test_dir).unwrap() {
let mut file_name = file_name.as_ref().unwrap().path();
if file_name.extension().map_or(true, |e| e != "eml") {
if file_name.extension().is_none_or(|e| e != "eml") {
continue;
}
let is_headers_test = file_name.file_name().unwrap() == "headers.eml";

6
tests/src/jmap/email_set.rs
View File

@@ -11,15 +11,15 @@ use ahash::AHashSet;
use ::email::mailbox::INBOX_ID;
use jmap_client::{
Error, Set,
client::Client,
core::set::{SetError, SetErrorType},
email::{self, Email},
mailbox::Role,
Error, Set,
};
use jmap_proto::types::id::Id;
use super::{find_values, replace_blob_ids, replace_boundaries, replace_values, JMAPTest};
use super::{JMAPTest, find_values, replace_blob_ids, replace_boundaries, replace_values};
pub async fn test(params: &mut JMAPTest) {
println!("Running Email Set tests...");
@@ -43,7 +43,7 @@ async fn create(client: &mut Client, mailbox_id: &str) {
for file_name in fs::read_dir(&test_dir).unwrap() {
let mut file_name = file_name.as_ref().unwrap().path();
if file_name.extension().map_or(true, |e| e != "json") {
if file_name.extension().is_none_or(|e| e != "json") {
continue;
}
println!("Creating email from {:?}", file_name);

10
tests/src/jmap/enterprise.rs
View File

@@ -472,16 +472,16 @@ pub async fn insert_test_metrics(core: Arc<Core>) {
EventType::IncomingReport(IncomingReportEvent::TlsReportWithWarnings),
] {
// Generate a random value between 0 and 100
Collector::update_event_counter(event_type, rand::thread_rng().gen_range(0..=100))
Collector::update_event_counter(event_type, rand::rng().random_range(0..=100))
}
Collector::update_gauge(
MetricType::QueueCount,
rand::thread_rng().gen_range(0..=1000),
rand::rng().random_range(0..=1000),
);
Collector::update_gauge(
MetricType::ServerMemory,
rand::thread_rng().gen_range(100 * 1024 * 1024..=300 * 1024 * 1024),
rand::rng().random_range(100 * 1024 * 1024..=300 * 1024 * 1024),
);
for metric_type in [
@@ -490,11 +490,11 @@ pub async fn insert_test_metrics(core: Arc<Core>) {
MetricType::DeliveryTime,
MetricType::DnsLookupTime,
] {
Collector::update_histogram(metric_type, rand::thread_rng().gen_range(2..=1000))
Collector::update_histogram(metric_type, rand::rng().random_range(2..=1000))
}
Collector::update_histogram(
MetricType::DeliveryTotalTime,
rand::thread_rng().gen_range(1000..=5000),
rand::rng().random_range(1000..=5000),
);
store

28
tests/src/jmap/mod.rs
View File

@@ -7,10 +7,11 @@
use std::{fmt::Debug, path::PathBuf, sync::Arc, time::Duration};
use base64::{
engine::general_purpose::{self, STANDARD},
Engine,
engine::general_purpose::{self, STANDARD},
};
use common::{
Caches, Core, Data, Inner, KV_BAYES_MODEL_GLOBAL, Server,
auth::AccessToken,
config::{
server::{Listeners, ServerProtocol},
@@ -21,31 +22,30 @@ use common::{
boot::build_ipc,
config::{ConfigManager, Patterns},
},
Caches, Core, Data, Inner, Server, KV_BAYES_MODEL_GLOBAL,
};
use enterprise::{insert_test_metrics, EnterpriseCore};
use hyper::{header::AUTHORIZATION, Method};
use enterprise::{EnterpriseCore, insert_test_metrics};
use hyper::{Method, header::AUTHORIZATION};
use imap::core::ImapSessionManager;
use jmap::{api::JmapSessionManager, email::delete::EmailDeletion, SpawnServices};
use jmap::{SpawnServices, api::JmapSessionManager, email::delete::EmailDeletion};
use jmap_client::client::{Client, Credentials};
use jmap_proto::{error::request::RequestError, types::id::Id};
use managesieve::core::ManageSieveSessionManager;
use pop3::Pop3SessionManager;
use reqwest::header;
use serde::{de::DeserializeOwned, Deserialize, Serialize};
use smtp::{core::SmtpSessionManager, SpawnQueueManager};
use serde::{Deserialize, Serialize, de::DeserializeOwned};
use smtp::{SpawnQueueManager, core::SmtpSessionManager};
use store::{
IterateParams, SUBSPACE_PROPERTY, Stores, ValueKey,
roaring::RoaringBitmap,
write::{key::DeserializeBigEndian, AnyKey, TaskQueueClass, ValueClass},
IterateParams, Stores, ValueKey, SUBSPACE_PROPERTY,
write::{AnyKey, TaskQueueClass, ValueClass, key::DeserializeBigEndian},
};
use tokio::sync::watch;
use utils::{config::Config, BlobHash};
use webhooks::{spawn_mock_webhook_endpoint, MockWebhookEndpoint};
use utils::{BlobHash, config::Config};
use webhooks::{MockWebhookEndpoint, spawn_mock_webhook_endpoint};
use crate::{
add_test_certs, directory::internal::TestInternalDirectory, store::TempDir, AssertConfig,
AssertConfig, add_test_certs, directory::internal::TestInternalDirectory, store::TempDir,
};
pub mod auth_acl;
@@ -384,13 +384,13 @@ pub async fn jmap_tests() {
thread_merge::test(&mut params).await;
mailbox::test(&mut params).await;
delivery::test(&mut params).await;
auth_acl::test(&mut params).await;
auth_acl::test(&mut params).await;*/
auth_limits::test(&mut params).await;
auth_oauth::test(&mut params).await;
event_source::test(&mut params).await;
push_subscription::test(&mut params).await;
sieve_script::test(&mut params).await;
vacation_response::test(&mut params).await;*/
vacation_response::test(&mut params).await;
email_submission::test(&mut params).await;
websocket::test(&mut params).await;
quota::test(&mut params).await;

22
tests/src/jmap/stress_test.rs
View File

@@ -65,13 +65,13 @@ async fn email_tests(server: Server, client: Arc<Client>) {
let mut futures = Vec::new();
for num in 0..1000 {
match rand::thread_rng().gen_range(0..3) {
match rand::rng().random_range(0..3) {
0 => {
let client = client.clone();
let mailboxes = mailboxes.clone();
futures.push(tokio::spawn(async move {
let mailbox_num =
rand::thread_rng().gen_range::<usize, _>(0..mailboxes.len());
rand::rng().random_range::<usize, _>(0..mailboxes.len());
let _message_id = client
.email_import(
format!(
@@ -107,7 +107,7 @@ async fn email_tests(server: Server, client: Arc<Client>) {
req.query_email();
let ids = req.send_query_email().await.unwrap().take_ids();
if !ids.is_empty() {
let message_id = &ids[rand::thread_rng().gen_range(0..ids.len())];
let message_id = &ids[rand::rng().random_range(0..ids.len())];
/*println!(
"Deleting message {}.",
Id::from_bytes(message_id.as_bytes()).unwrap().document_id()
@@ -159,14 +159,14 @@ async fn email_tests(server: Server, client: Arc<Client>) {
.take_list();
if !emails.is_empty() {
let message = &emails[rand::thread_rng().gen_range(0..emails.len())];
let message = &emails[rand::rng().random_range(0..emails.len())];
let message_id = message.id().unwrap();
let mailbox_ids = message.mailbox_ids();
assert_eq!(mailbox_ids.len(), 1, "{:#?}", message);
let mailbox_id = mailbox_ids.last().unwrap();
loop {
let new_mailbox_id =
&mailboxes[rand::thread_rng().gen_range(0..mailboxes.len())];
&mailboxes[rand::rng().random_range(0..mailboxes.len())];
if new_mailbox_id != mailbox_id {
/*println!(
"Moving message {} from {} to {}.",
@@ -193,7 +193,7 @@ async fn email_tests(server: Server, client: Arc<Client>) {
}));
}
}
tokio::time::sleep(Duration::from_millis(rand::thread_rng().gen_range(5..10))).await;
tokio::time::sleep(Duration::from_millis(rand::rng().random_range(5..10))).await;
}
join_all(futures).await;
@@ -285,7 +285,7 @@ async fn mailbox_tests(server: Server, client: Arc<Client>) {
println!("----------------- MAILBOX STRESS TEST -----------------");
for _ in 0..1000 {
match rand::thread_rng().gen_range(0..=3) {
match rand::rng().random_range(0..=3) {
0 => {
for pos in 0..mailboxes.len() {
let client = client.clone();
@@ -332,15 +332,15 @@ async fn mailbox_tests(server: Server, client: Arc<Client>) {
.unwrap()
.take_ids();
if !ids.is_empty() {
let id = ids.swap_remove(rand::thread_rng().gen_range(0..ids.len()));
let sort_order = rand::thread_rng().gen_range(0..100);
let id = ids.swap_remove(rand::rng().random_range(0..ids.len()));
let sort_order = rand::rng().random_range(0..100);
//println!("Updating mailbox {}.", id);
client.mailbox_update_sort_order(&id, sort_order).await.ok();
}
}));
}
}
tokio::time::sleep(Duration::from_millis(rand::thread_rng().gen_range(5..10))).await;
tokio::time::sleep(Duration::from_millis(rand::rng().random_range(5..10))).await;
}
join_all(futures).await;
@@ -421,7 +421,7 @@ async fn delete_mailbox(client: &Client, mailbox_id: &str) {
Err(err) => match err {
jmap_client::Error::Set(_) => break,
jmap_client::Error::Transport(_) => {
let backoff = rand::thread_rng().gen_range(50..=300);
let backoff = rand::rng().random_range(50..=300);
tokio::time::sleep(Duration::from_millis(backoff)).await;
}
_ => panic!("Failed: {:?}", err),

2
tests/src/jmap/thread_merge.rs
View File

@@ -261,7 +261,7 @@ async fn test_multi_thread(params: &mut JMAPTest) {
Err(err) => {
if err.is_assertion_failure() && retry_count < 10 {
//println!("Retrying ingest for {}...", message.from());
let backoff = rand::thread_rng().gen_range(50..=300);
let backoff = rand::rng().random_range(50..=300);
tokio::time::sleep(Duration::from_millis(backoff)).await;
retry_count += 1;
continue;

42
tests/src/store/lookup.rs
View File

@@ -6,12 +6,12 @@
use std::time::Duration;
use store::{dispatch::lookup::KeyValue, InMemoryStore, Stores};
use store::{InMemoryStore, Stores, dispatch::lookup::KeyValue};
use utils::config::{Config, Rate};
use crate::{
store::{TempDir, CONFIG},
AssertConfig,
store::{CONFIG, TempDir},
};
#[tokio::test]
@@ -98,22 +98,28 @@ pub async fn lookup_tests() {
assert_eq!(0, store.counter_get(key.clone()).await.unwrap());
// Test rate limiter
assert!(store
.is_rate_allowed(0, "rate".as_bytes(), &rate, false)
.await
.unwrap()
.is_none());
assert!(store
.is_rate_allowed(0, "rate".as_bytes(), &rate, false)
.await
.unwrap()
.is_some());
assert!(
store
.is_rate_allowed(0, "rate".as_bytes(), &rate, false)
.await
.unwrap()
.is_none()
);
assert!(
store
.is_rate_allowed(0, "rate".as_bytes(), &rate, false)
.await
.unwrap()
.is_some()
);
tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
assert!(store
.is_rate_allowed(0, "rate".as_bytes(), &rate, false)
.await
.unwrap()
.is_none());
assert!(
store
.is_rate_allowed(0, "rate".as_bytes(), &rate, false)
.await
.unwrap()
.is_none()
);
tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
store.purge_in_memory_store().await.unwrap();
if let InMemoryStore::Store(store) = &store {
@@ -281,5 +287,5 @@ pub async fn lookup_tests() {
}
fn pack_u32(a: u32, b: u32) -> Vec<u8> {
((a as u64) << 32 | b as u64).to_be_bytes().to_vec()
(((a as u64) << 32) | b as u64).to_be_bytes().to_vec()
}