refactor: remove timesmearing

deltachat-rpc-client/tests/test_something.py

@@ -1091,6 +1091,7 @@ def test_rename_group(acfactory):
     bob.wait_for_event(EventType.CHATLIST_ITEM_CHANGED)
 
     for name in ["Baz", "Foo bar", "Xyzzy"]:
+        time.sleep(1)
         alice_group.set_name(name)
         bob.wait_for_event(EventType.CHATLIST_ITEM_CHANGED)
         bob.wait_for_event(EventType.CHATLIST_ITEM_CHANGED)

src/chat.rs

@@ -49,8 +49,8 @@ use crate::stock_str;
 use crate::sync::{self, Sync::*, SyncData};
 use crate::tools::{
     IsNoneOrEmpty, SystemTime, buf_compress, create_broadcast_secret, create_id,
-    create_outgoing_rfc724_mid, create_smeared_timestamp, create_smeared_timestamps, get_abs_path,
-    gm2local_offset, normalize_text, smeared_time, time, truncate_msg_text,
+    create_outgoing_rfc724_mid, get_abs_path, gm2local_offset, normalize_text, time,
+    truncate_msg_text,
 };
 use crate::webxdc::StatusUpdateSerial;
 
@@ -291,7 +291,7 @@ impl ChatId {
         timestamp: i64,
     ) -> Result<Self> {
         let grpname = sanitize_single_line(grpname);
-        let timestamp = cmp::min(timestamp, smeared_time(context));
+        let timestamp = cmp::min(timestamp, time());
         let row_id =
             context.sql.insert(
                 "INSERT INTO chats (type, name, name_normalized, grpid, blocked, created_timestamp, protected, param) VALUES(?, ?, ?, ?, ?, ?, 0, ?)",
@@ -1255,7 +1255,7 @@ SELECT id, rfc724_mid, pre_rfc724_mid, timestamp, ?, 1 FROM msgs WHERE chat_id=?
         message_timestamp: i64,
         always_sort_to_bottom: bool,
     ) -> Result<i64> {
-        let mut sort_timestamp = cmp::min(message_timestamp, smeared_time(context));
+        let mut sort_timestamp = cmp::min(message_timestamp, time());
 
         let last_msg_time: Option<i64> = if always_sort_to_bottom {
             // get newest message for this chat
@@ -2405,7 +2405,7 @@ impl ChatIdBlocked {
             _ => (),
         }
 
-        let smeared_time = create_smeared_timestamp(context);
+        let now = time();
 
         let chat_id = context
             .sql
@@ -2420,7 +2420,7 @@ impl ChatIdBlocked {
                         normalize_text(&chat_name),
                         params.to_string(),
                         create_blocked as u8,
-                        smeared_time,
+                        now,
                     ),
                 )?;
                 let chat_id = ChatId::new(
@@ -2446,7 +2446,7 @@ impl ChatIdBlocked {
             && !chat.param.exists(Param::Devicetalk)
             && !chat.param.exists(Param::Selftalk)
         {
-            chat_id.add_e2ee_notice(context, smeared_time).await?;
+            chat_id.add_e2ee_notice(context, now).await?;
         }
 
         Ok(Self {
@@ -2733,7 +2733,7 @@ async fn prepare_send_msg(
     }
     msg.state = MessageState::OutPending;
 
-    msg.timestamp_sort = create_smeared_timestamp(context);
+    msg.timestamp_sort = time();
     prepare_msg_blob(context, msg).await?;
     if !msg.hidden {
         chat_id.unarchive_if_not_muted(context, msg.state).await?;
@@ -2907,7 +2907,7 @@ pub(crate) async fn create_send_msg_jobs(context: &Context, msg: &mut Message) -
         );
     }
 
-    let now = smeared_time(context);
+    let now = time();
 
     if rendered_msg.last_added_location_id.is_some()
         && let Err(err) = location::set_kml_sent_timestamp(context, msg.chat_id, now).await
@@ -3549,7 +3549,7 @@ pub(crate) async fn create_group_ex(
         chat_name = "…".to_string();
     }
 
-    let timestamp = create_smeared_timestamp(context);
+    let timestamp = time();
     let row_id = context
         .sql
         .insert(
@@ -3635,7 +3635,7 @@ pub(crate) async fn create_out_broadcast_ex(
         bail!("Invalid broadcast channel name: {chat_name}.");
     }
 
-    let timestamp = create_smeared_timestamp(context);
+    let timestamp = time();
     let trans_fn = |t: &mut rusqlite::Transaction| -> Result<ChatId> {
         let cnt: u32 = t.query_row(
             "SELECT COUNT(*) FROM chats WHERE grpid=?",
@@ -3885,11 +3885,11 @@ pub(crate) async fn add_contact_to_chat_ex(
         return Ok(false);
     }
     if from_handshake && chat.param.get_int(Param::Unpromoted).unwrap_or_default() == 1 {
-        let smeared_time = smeared_time(context);
+        let now = time();
         chat.param
             .remove(Param::Unpromoted)
-            .set_i64(Param::GroupNameTimestamp, smeared_time)
-            .set_i64(Param::GroupDescriptionTimestamp, smeared_time);
+            .set_i64(Param::GroupNameTimestamp, now)
+            .set_i64(Param::GroupDescriptionTimestamp, now);
         chat.update_param(context).await?;
     }
     if context.is_self_addr(contact.get_addr()).await? {
@@ -4452,7 +4452,6 @@ pub async fn forward_msgs(context: &Context, msg_ids: &[MsgId], chat_id: ChatId)
 }
 
 /// Forwards multiple messages to a chat in another context.
-#[expect(clippy::arithmetic_side_effects)]
 pub async fn forward_msgs_2ctx(
     ctx_src: &Context,
     msg_ids: &[MsgId],
@@ -4463,7 +4462,6 @@ pub async fn forward_msgs_2ctx(
     ensure!(!chat_id.is_special(), "can not forward to special chat");
 
     let mut created_msgs: Vec<MsgId> = Vec::new();
-    let mut curr_timestamp: i64;
 
     chat_id
         .unarchive_if_not_muted(ctx_dst, MessageState::Undefined)
@@ -4472,7 +4470,7 @@ pub async fn forward_msgs_2ctx(
     if let Some(reason) = chat.why_cant_send(ctx_dst).await? {
         bail!("cannot send to {chat_id}: {reason}");
     }
-    curr_timestamp = create_smeared_timestamps(ctx_dst, msg_ids.len());
+    let now = time();
     let mut msgs = Vec::with_capacity(msg_ids.len());
     for id in msg_ids {
         let ts: i64 = ctx_src
@@ -4537,10 +4535,9 @@ pub async fn forward_msgs_2ctx(
         msg.state = MessageState::OutPending;
         msg.rfc724_mid = create_outgoing_rfc724_mid();
         msg.pre_rfc724_mid.clear();
-        msg.timestamp_sort = curr_timestamp;
+        msg.timestamp_sort = now;
         chat.prepare_msg_raw(ctx_dst, &mut msg, None).await?;
 
-        curr_timestamp += 1;
         if !create_send_msg_jobs(ctx_dst, &mut msg).await?.is_empty() {
             ctx_dst.scheduler.interrupt_smtp().await;
         }
@@ -4633,7 +4630,7 @@ pub(crate) async fn save_copy_in_self_talk(
                 } else {
                     MessageState::InSeen
                 },
-                create_smeared_timestamp(context),
+                time(),
                 msg.param.to_string(),
                 src_msg_id,
                 src_msg_id,
@@ -4810,7 +4807,7 @@ pub async fn add_device_msg_with_importance(
         chat_id = ChatId::get_for_contact(context, ContactId::DEVICE).await?;
 
         let rfc724_mid = create_outgoing_rfc724_mid();
-        let timestamp_sent = create_smeared_timestamp(context);
+        let timestamp_sent = time();
 
         // makes sure, the added message is the last one,
         // even if the date is wrong (useful esp. when warning about bad dates)
@@ -4957,7 +4954,7 @@ pub(crate) async fn add_info_msg_with_cmd(
     } else {
         let sort_to_bottom = true;
         chat_id
-            .calc_sort_timestamp(context, smeared_time(context), sort_to_bottom)
+            .calc_sort_timestamp(context, time(), sort_to_bottom)
             .await?
     };
 
@@ -5120,7 +5117,7 @@ async fn set_contacts_by_fingerprints(
             Ok(broadcast_contacts_added)
         })
         .await?;
-    let timestamp = smeared_time(context);
+    let timestamp = time();
     for added_id in broadcast_contacts_added {
         let msg = stock_str::msg_add_member_local(context, added_id, ContactId::UNDEFINED).await;
         add_info_msg_with_cmd(

src/chat/chat_tests.rs

@@ -1049,7 +1049,6 @@ async fn chatlist_len(ctx: &Context, listflags: usize) -> usize {
 async fn test_archive() {
     // create two chats
     let t = TestContext::new_alice().await;
-
     let mut msg = Message::new_text("foo".to_string());
     let msg_id = add_device_msg(&t, None, Some(&mut msg)).await.unwrap();
     let chat_id1 = message::Message::load_from_db(&t, msg_id)
@@ -1382,9 +1381,6 @@ async fn test_markfresh_chat() -> Result<()> {
 async fn test_archive_fresh_msgs() -> Result<()> {
     let t = TestContext::new_alice().await;
 
-    // FIXME: use encrypted messages
-    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
-
     async fn msg_from(t: &TestContext, name: &str, num: u32) -> Result<()> {
         receive_imf(
             t,
@@ -1629,6 +1625,7 @@ async fn test_set_chat_name() {
         "another name",
         "something different",
     ] {
+        SystemTime::shift(Duration::from_secs(1));
         set_chat_name(alice, chat_id, new_name).await.unwrap();
         let sent_msg = alice.pop_sent_msg().await;
         let received_msg = bob.recv_msg(&sent_msg).await;
@@ -1877,38 +1874,45 @@ async fn test_lookup_self_by_contact_id() {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_marknoticed_chat() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let alice = &tcm.alice().await;
-    let bob = &tcm.bob().await;
-    let chat = alice.create_chat(bob).await;
+    let t = TestContext::new_alice().await;
+    let chat = t.create_chat_with_contact("bob", "bob@example.org").await;
 
-    let bob_chat_id = bob.create_chat_id(alice).await;
-    let sent = bob.send_text(bob_chat_id, "hello").await;
-    alice.recv_msg(&sent).await;
+    receive_imf(
+        &t,
+        b"From: bob@example.org\n\
+                 To: alice@example.org\n\
+                 Message-ID: <1@example.org>\n\
+                 Chat-Version: 1.0\n\
+                 Date: Fri, 23 Apr 2021 10:00:57 +0000\n\
+                 \n\
+                 hello\n",
+        false,
+    )
+    .await?;
 
-    let chats = Chatlist::try_load(alice, 0, None, None).await?;
+    let chats = Chatlist::try_load(&t, 0, None, None).await?;
     assert_eq!(chats.len(), 1);
     assert_eq!(chats.get_chat_id(0)?, chat.id);
-    assert_eq!(chat.id.get_fresh_msg_cnt(alice).await?, 1);
-    assert_eq!(alice.get_fresh_msgs().await?.len(), 1);
+    assert_eq!(chat.id.get_fresh_msg_cnt(&t).await?, 1);
+    assert_eq!(t.get_fresh_msgs().await?.len(), 1);
 
-    let msgs = get_chat_msgs(alice, chat.id).await?;
-    assert_eq!(msgs.len(), 2);
-    let msg_id = match msgs.last().unwrap() {
+    let msgs = get_chat_msgs(&t, chat.id).await?;
+    assert_eq!(msgs.len(), 1);
+    let msg_id = match msgs.first().unwrap() {
         ChatItem::Message { msg_id } => *msg_id,
         _ => MsgId::new_unset(),
     };
-    let msg = message::Message::load_from_db(alice, msg_id).await?;
+    let msg = message::Message::load_from_db(&t, msg_id).await?;
     assert_eq!(msg.state, MessageState::InFresh);
 
-    marknoticed_chat(alice, chat.id).await?;
+    marknoticed_chat(&t, chat.id).await?;
 
-    let chats = Chatlist::try_load(alice, 0, None, None).await?;
+    let chats = Chatlist::try_load(&t, 0, None, None).await?;
     assert_eq!(chats.len(), 1);
-    let msg = message::Message::load_from_db(alice, msg_id).await?;
+    let msg = message::Message::load_from_db(&t, msg_id).await?;
     assert_eq!(msg.state, MessageState::InNoticed);
-    assert_eq!(chat.id.get_fresh_msg_cnt(alice).await?, 0);
-    assert_eq!(alice.get_fresh_msgs().await?.len(), 0);
+    assert_eq!(chat.id.get_fresh_msg_cnt(&t).await?, 0);
+    assert_eq!(t.get_fresh_msgs().await?.len(), 0);
 
     Ok(())
 }
@@ -1916,7 +1920,6 @@ async fn test_marknoticed_chat() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_contact_request_fresh_messages() -> Result<()> {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
 
     let chats = Chatlist::try_load(&t, 0, None, None).await?;
     assert_eq!(chats.len(), 0);
@@ -1968,43 +1971,40 @@ async fn test_contact_request_fresh_messages() -> Result<()> {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_contact_request_archive() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let alice = &tcm.alice().await;
-    let bob = &tcm.bob().await;
+    let t = TestContext::new_alice().await;
 
-    let bob_chat_id = bob.create_chat_id(alice).await;
-    let bob_sent_text = bob.send_text(bob_chat_id, "hello").await;
-    alice.recv_msg(&bob_sent_text).await;
+    receive_imf(
+        &t,
+        b"From: bob@example.org\n\
+                 To: alice@example.org\n\
+                 Message-ID: <2@example.org>\n\
+                 Chat-Version: 1.0\n\
+                 Date: Sun, 22 Mar 2021 19:37:57 +0000\n\
+                 \n\
+                 hello\n",
+        false,
+    )
+    .await?;
 
-    let chats = Chatlist::try_load(alice, 0, None, None).await?;
+    let chats = Chatlist::try_load(&t, 0, None, None).await?;
     assert_eq!(chats.len(), 1);
     let chat_id = chats.get_chat_id(0)?;
-    assert!(
-        Chat::load_from_db(alice, chat_id)
-            .await?
-            .is_contact_request()
-    );
-    assert_eq!(get_archived_cnt(alice).await?, 0);
+    assert!(Chat::load_from_db(&t, chat_id).await?.is_contact_request());
+    assert_eq!(get_archived_cnt(&t).await?, 0);
 
     // archive request without accepting or blocking
-    chat_id
-        .set_visibility(alice, ChatVisibility::Archived)
-        .await?;
+    chat_id.set_visibility(&t, ChatVisibility::Archived).await?;
 
-    let chats = Chatlist::try_load(alice, 0, None, None).await?;
+    let chats = Chatlist::try_load(&t, 0, None, None).await?;
     assert_eq!(chats.len(), 1);
     let chat_id = chats.get_chat_id(0)?;
     assert!(chat_id.is_archived_link());
-    assert_eq!(get_archived_cnt(alice).await?, 1);
+    assert_eq!(get_archived_cnt(&t).await?, 1);
 
-    let chats = Chatlist::try_load(alice, DC_GCL_ARCHIVED_ONLY, None, None).await?;
+    let chats = Chatlist::try_load(&t, DC_GCL_ARCHIVED_ONLY, None, None).await?;
     assert_eq!(chats.len(), 1);
     let chat_id = chats.get_chat_id(0)?;
-    assert!(
-        Chat::load_from_db(alice, chat_id)
-            .await?
-            .is_contact_request()
-    );
+    assert!(Chat::load_from_db(&t, chat_id).await?.is_contact_request());
 
     Ok(())
 }
@@ -2012,9 +2012,6 @@ async fn test_contact_request_archive() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_classic_email_chat() -> Result<()> {
     let alice = TestContext::new_alice().await;
-    alice
-        .set_config(Config::ProcessUnencrypted, Some("1"))
-        .await?;
 
     // Alice receives a classic (non-chat) message from Bob.
     receive_imf(
@@ -3441,8 +3438,9 @@ async fn test_chat_description(
         "",
         "ä ẟ 😂",
     ] {
+        SystemTime::shift(Duration::from_secs(1));
         tcm.section(&format!(
-            "Alice sets the chat description to '{description}'"
+            "Alice sets the chat description to {description:?}"
         ));
         set_chat_description(alice, alice_chat_id, description).await?;
         let sent = alice.pop_sent_msg().await;
@@ -4463,7 +4461,9 @@ async fn test_get_chat_media_webxdc_order() -> Result<()> {
     assert_eq!(media.first().unwrap(), &instance1_id);
     assert_eq!(media.get(1).unwrap(), &instance2_id);
 
-    // add a status update for the oder instance; that resorts the list
+    SystemTime::shift(Duration::from_secs(1));
+
+    // add a status update for the other instance; that resorts the list
     alice
         .send_webxdc_status_update(instance1_id, r#"{"payload": {"foo": "bar"}}"#)
         .await?;
@@ -4877,10 +4877,6 @@ async fn test_sync_broadcast_and_send_message() -> Result<()> {
         vec![a2b_contact_id]
     );
 
-    // alice2's smeared clock may be behind alice1's one, so we need to work around "hi" appearing
-    // before "You joined the channel." for bob. alice1 makes 3 more calls of
-    // create_smeared_timestamp() than alice2 does as of 2026-03-10.
-    SystemTime::shift(Duration::from_secs(3));
     tcm.section("Alice's second device sends a message to the channel");
     let sent_msg = alice2.send_text(a2_broadcast_id, "hi").await;
     let msg = bob.recv_msg(&sent_msg).await;

src/chatlist.rs

@@ -473,7 +473,6 @@ mod tests {
         add_contact_to_chat, create_broadcast, create_group, get_chat_contacts,
         remove_contact_from_chat, send_text_msg, set_chat_name,
     };
-    use crate::config::Config;
     use crate::receive_imf::receive_imf;
     use crate::securejoin::get_securejoin_qr;
     use crate::stock_str::StockMessage;
@@ -666,7 +665,6 @@ mod tests {
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_search_single_chat() -> anyhow::Result<()> {
         let t = TestContext::new_alice().await;
-        t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
 
         // receive a one-to-one-message
         receive_imf(
@@ -727,7 +725,6 @@ mod tests {
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_search_single_chat_without_authname() -> anyhow::Result<()> {
         let t = TestContext::new_alice().await;
-        t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
 
         // receive a one-to-one-message without authname set
         receive_imf(

src/config.rs

@@ -486,11 +486,6 @@ pub enum Config {
     /// Experimental option denoting that the current profile is shared between multiple team members.
     /// For now, the only effect of this option is that seen flags are not synchronized.
     TeamProfile,
-
-    /// Process unencrypted messages.
-    ///
-    /// Unencrypted messages are fetched and processed only if this setting is explicitly enabled.
-    ProcessUnencrypted,
 }
 
 impl Config {

src/context.rs

@@ -32,7 +32,6 @@ use crate::quota::QuotaInfo;
 use crate::scheduler::{ConnectivityStore, SchedulerState};
 use crate::sql::Sql;
 use crate::stock_str::StockStrings;
-use crate::timesmearing::SmearedTimestamp;
 use crate::tools::{self, duration_to_str, time, time_elapsed};
 use crate::transport::ConfiguredLoginParam;
 use crate::{chatlist_events, stats};
@@ -228,7 +227,6 @@ pub struct InnerContext {
     /// Blob directory path
     pub(crate) blobdir: PathBuf,
     pub(crate) sql: Sql,
-    pub(crate) smeared_timestamp: SmearedTimestamp,
     /// The global "ongoing" process state.
     ///
     /// This is a global mutex-like state for operations which should be modal in the
@@ -498,7 +496,6 @@ impl Context {
             blobdir,
             running_state: RwLock::new(Default::default()),
             sql: Sql::new(dbfile),
-            smeared_timestamp: SmearedTimestamp::new(),
             oauth2_mutex: Mutex::new(()),
             wrong_pw_warning_mutex: Mutex::new(()),
             housekeeping_mutex: Mutex::new(()),
@@ -1056,12 +1053,6 @@ impl Context {
             "team_profile",
             self.get_config_bool(Config::TeamProfile).await?.to_string(),
         );
-        res.insert(
-            "process_unencrypted",
-            self.get_config_bool(Config::ProcessUnencrypted)
-                .await?
-                .to_string(),
-        );
 
         let elapsed = time_elapsed(&self.creation_time);
         res.insert("uptime", duration_to_str(elapsed));

src/decrypt.rs

@@ -370,7 +370,6 @@ mod tests {
     use super::*;
     use crate::receive_imf::receive_imf;
     use crate::test_utils::TestContext;
-    use crate::config::Config;
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_mixed_up_mime() -> Result<()> {
@@ -403,7 +402,6 @@ mod tests {
         assert!(get_attachment_mime(&mail).is_some());
 
         let bob = TestContext::new_bob().await;
-        bob.set_config(Config::ProcessUnencrypted, Some("1")).await?;
         receive_imf(&bob, attachment_mime, false).await?;
         let msg = bob.get_last_msg().await;
         // Subject should be prepended because the attachment doesn't have "Chat-Version".
@@ -418,7 +416,6 @@ mod tests {
         // Desktop via MS Exchange (actually made with TB though).
         let mixed_up_mime = include_bytes!("../test-data/message/mixed-up-long.eml");
         let bob = TestContext::new_bob().await;
-        bob.set_config(Config::ProcessUnencrypted, Some("1")).await?;
         receive_imf(&bob, mixed_up_mime, false).await?;
         let msg = bob.get_last_msg().await;
         assert!(!msg.get_text().is_empty());

src/e2ee.rs

@@ -42,25 +42,12 @@ impl EncryptHelper {
         compress: bool,
         seipd_version: SeipdVersion,
     ) -> Result<String> {
+        let sign_key = load_self_secret_key(context).await?;
+
         let mut raw_message = Vec::new();
         let cursor = Cursor::new(&mut raw_message);
         mail_to_encrypt.clone().write_part(cursor).ok();
 
-        let ctext = self
-            .encrypt_raw(context, keyring, raw_message, compress, seipd_version)
-            .await?;
-        Ok(ctext)
-    }
-
-    pub async fn encrypt_raw(
-        self,
-        context: &Context,
-        keyring: Vec<SignedPublicKey>,
-        raw_message: Vec<u8>,
-        compress: bool,
-        seipd_version: SeipdVersion,
-    ) -> Result<String> {
-        let sign_key = load_self_secret_key(context).await?;
         let ctext =
             pgp::pk_encrypt(raw_message, keyring, sign_key, compress, seipd_version).await?;
 
@@ -160,8 +147,6 @@ Sent with my Delta Chat Messenger: https://delta.chat";
         let mut tcm = TestContextManager::new();
         let bob = &tcm.bob().await;
         bob.set_config_bool(Config::IsChatmail, true).await?;
-        bob.set_config_bool(Config::ProcessUnencrypted, true)
-            .await?;
         let bob_chat_id = receive_imf(
             bob,
             b"From: alice@example.org\n\

src/ephemeral/ephemeral_tests.rs

@@ -10,7 +10,6 @@ use crate::location;
 use crate::message::markseen_msgs;
 use crate::receive_imf::receive_imf;
 use crate::test_utils::{TestContext, TestContextManager};
-use crate::timesmearing::MAX_SECONDS_TO_LEND_FROM_FUTURE;
 use crate::{
     chat::{self, Chat, ChatItem, create_group, send_text_msg},
     tools::IsNoneOrEmpty,
@@ -352,17 +351,9 @@ async fn test_ephemeral_delete_msgs() -> Result<()> {
     let now = time();
     let msg = t.send_text(bob_chat.id, "Message text").await;
 
-    check_msg_will_be_deleted(
-        &t,
-        msg.sender_msg_id,
-        &bob_chat,
-        now + 1799,
-        // The message may appear to be sent MAX_SECONDS_TO_LEND_FROM_FUTURE later and
-        // therefore be deleted MAX_SECONDS_TO_LEND_FROM_FUTURE later.
-        time() + 1801 + MAX_SECONDS_TO_LEND_FROM_FUTURE,
-    )
-    .await
-    .unwrap();
+    check_msg_will_be_deleted(&t, msg.sender_msg_id, &bob_chat, now + 1799, time() + 1801)
+        .await
+        .unwrap();
 
     // Enable ephemeral messages with Bob -> message will be deleted after 60s.
     // This tests that the message is deleted at min(ephemeral deletion time, DeleteDeviceAfter deletion time).

src/html.rs

@@ -287,7 +287,6 @@ impl MsgId {
 mod tests {
     use super::*;
     use crate::chat::{self, Chat, forward_msgs, save_msgs};
-    use crate::config::Config;
     use crate::constants;
     use crate::contact::ContactId;
     use crate::message::{MessengerMessage, Viewtype};
@@ -451,9 +450,6 @@ test some special html-characters as < > and & but also " and &#x
         // alice receives a non-delta html-message
         let mut tcm = TestContextManager::new();
         let alice = &tcm.alice().await;
-        alice
-            .set_config(Config::ProcessUnencrypted, Some("1"))
-            .await?;
         let chat = alice
             .create_chat_with_contact("", "sender@testrun.org")
             .await;
@@ -487,8 +483,6 @@ test some special html-characters as < > and & but also " and &#x
 
         // bob: check that bob also got the html-part of the forwarded message
         let bob = &tcm.bob().await;
-        bob.set_config(Config::ProcessUnencrypted, Some("1"))
-            .await?;
         let chat_bob = bob.create_chat_with_contact("", "alice@example.org").await;
         async fn check_receiver(ctx: &TestContext, chat: &Chat, sender: &TestContext) {
             let msg = ctx.recv_msg(&sender.pop_sent_msg().await).await;
@@ -526,12 +520,8 @@ test some special html-characters as < > and & but also " and &#x
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_html_save_msg() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = &tcm.alice().await;
-        alice
-            .set_config(Config::ProcessUnencrypted, Some("1"))
-            .await?;
         // Alice receives a non-delta html-message
+        let alice = TestContext::new_alice().await;
         let chat = alice
             .create_chat_with_contact("", "sender@testrun.org")
             .await;
@@ -565,10 +555,6 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
         let mut tcm = TestContextManager::new();
         // Alice receives a non-delta html-message
         let alice = &tcm.alice().await;
-        alice
-            .set_config(Config::ProcessUnencrypted, Some("1"))
-            .await
-            .unwrap();
         let chat = alice
             .create_chat_with_contact("", "sender@testrun.org")
             .await;
@@ -632,22 +618,18 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_cp1252_html() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = &tcm.alice().await;
-        alice
-            .set_config(Config::ProcessUnencrypted, Some("1"))
-            .await?;
+        let t = TestContext::new_alice().await;
         receive_imf(
-            alice,
+            &t,
             include_bytes!("../test-data/message/cp1252-html.eml"),
             false,
         )
         .await?;
-        let msg = alice.get_last_msg().await;
+        let msg = t.get_last_msg().await;
         assert_eq!(msg.viewtype, Viewtype::Text);
         assert!(msg.text.contains("foo bar ä ö ü ß"));
         assert!(msg.has_html());
-        let html = msg.get_id().get_html(alice).await?.unwrap();
+        let html = msg.get_id().get_html(&t).await?.unwrap();
         println!("{html}");
         assert!(html.contains("foo bar ä ö ü ß"));
         Ok(())

src/imap.rs

@@ -1996,21 +1996,12 @@ pub(crate) async fn prefetch_should_download(
     // prevent_rename=true as this might be a mailing list message and in this case it would be bad if we rename the contact.
     // (prevent_rename is the last argument of from_field_to_contact_id())
 
-    let is_encrypted = if let Some(content_type) = headers.get_header_value(HeaderDef::ContentType)
-    {
-        mailparse::parse_content_type(&content_type).mimetype == "multipart/encrypted"
-    } else {
-        false
-    };
-
     if flags.any(|f| f == Flag::Draft) {
         info!(context, "Ignoring draft message");
         return Ok(false);
     }
 
-    let should_download = maybe_ndn
-        || (!blocked_contact
-            && (is_encrypted || context.get_config_bool(Config::ProcessUnencrypted).await?));
+    let should_download = !blocked_contact || maybe_ndn;
     Ok(should_download)
 }
 

src/imap/session.rs

@@ -21,7 +21,6 @@ const PREFETCH_FLAGS: &str = "(UID RFC822.SIZE BODY.PEEK[HEADER.FIELDS (\
                               DATE \
                               X-MICROSOFT-ORIGINAL-MESSAGE-ID \
                               FROM \
-                              CONTENT-TYPE \
                               CHAT-VERSION \
                               CHAT-IS-POST-MESSAGE \
                               AUTOCRYPT-SETUP-MESSAGE\

src/lib.rs

@@ -94,7 +94,6 @@ mod smtp;
 pub mod stock_str;
 pub mod storage_usage;
 mod sync;
-mod timesmearing;
 mod token;
 mod transport;
 mod update_helper;

src/location.rs

@@ -871,7 +871,6 @@ mod tests {
     use crate::config::Config;
     use crate::message::MessageState;
     use crate::receive_imf::receive_imf;
-    use crate::test_utils;
     use crate::test_utils::{ExpectedEvents, TestContext, TestContextManager};
     use crate::tools::SystemTime;
 
@@ -940,15 +939,12 @@ mod tests {
     /// Tests that location.kml is hidden.
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn receive_location_kml() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = &tcm.alice().await;
-        let bob = &tcm.bob().await;
+        let alice = TestContext::new_alice().await;
 
-        let encrypted_message = test_utils::encrypt_raw_message(
-            bob,
-            &[alice],
+        receive_imf(
+            &alice,
             br#"Subject: Hello
-Message-ID: <hello@example.net>
+Message-ID: hello@example.net
 To: Alice <alice@example.org>
 From: Bob <bob@example.net>
 Date: Mon, 20 Dec 2021 00:00:00 +0000
@@ -956,15 +952,14 @@ Chat-Version: 1.0
 Content-Type: text/plain; charset=utf-8; format=flowed; delsp=no
 
 Text message."#,
+            false,
         )
         .await?;
-        receive_imf(alice, encrypted_message.as_bytes(), false).await?;
         let received_msg = alice.get_last_msg().await;
         assert_eq!(received_msg.text, "Text message.");
 
-        let encrypted_message = test_utils::encrypt_raw_message(
-            bob,
-            &[alice],
+        receive_imf(
+            &alice,
             br#"Subject: locations
 MIME-Version: 1.0
 To: <alice@example.org>
@@ -991,8 +986,10 @@ Content-Disposition: attachment; filename="location.kml"
 </Document>
 </kml>
 
---U8BOG8qNXfB0GgLiQ3PKUjlvdIuLRF--"#).await?;
-        receive_imf(alice, encrypted_message.as_bytes(), false).await?;
+--U8BOG8qNXfB0GgLiQ3PKUjlvdIuLRF--"#,
+            false,
+        )
+        .await?;
 
         // Received location message is not visible, last message stays the same.
         let received_msg2 = alice.get_last_msg().await;

src/message/message_tests.rs

@@ -139,14 +139,23 @@ async fn test_unencrypted_quote_encrypted_message() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_get_chat_id() {
     // Alice receives a message that pops up as a contact request
-    let mut tcm = TestContextManager::new();
-    let alice = &tcm.alice().await;
-    let bob = &tcm.bob().await;
-    let chat_id = bob.create_chat_id(alice).await;
-    let sent = bob.send_text(chat_id, "hello").await;
-    let msg = bob.recv_msg(&sent).await;
+    let alice = TestContext::new_alice().await;
+    receive_imf(
+        &alice,
+        b"From: Bob <bob@example.com>\n\
+                    To: alice@example.org\n\
+                    Chat-Version: 1.0\n\
+                    Message-ID: <123@example.com>\n\
+                    Date: Fri, 29 Jan 2021 21:37:55 +0000\n\
+                    \n\
+                    hello\n",
+        false,
+    )
+    .await
+    .unwrap();
 
     // check chat-id of this message
+    let msg = alice.get_last_msg().await;
     assert!(!msg.get_chat_id().is_special());
     assert_eq!(msg.get_text(), "hello".to_string());
 }
@@ -456,9 +465,7 @@ async fn test_get_state() -> Result<()> {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_is_bot() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let alice = &tcm.alice().await;
-    alice.set_config(Config::ProcessUnencrypted, Some("1")).await?;
+    let alice = TestContext::new_alice().await;
 
     // Alice receives an auto-generated non-chat message.
     //
@@ -466,7 +473,7 @@ async fn test_is_bot() -> Result<()> {
     // in which case the message should be marked as bot-generated,
     // but the contact should not.
     receive_imf(
-        alice,
+        &alice,
         b"From: Claire <claire@example.com>\n\
                     To: alice@example.org\n\
                     Message-ID: <789@example.com>\n\
@@ -485,7 +492,7 @@ async fn test_is_bot() -> Result<()> {
 
     // Alice receives a message from Bob the bot.
     receive_imf(
-        alice,
+        &alice,
         b"From: Bob <bob@example.com>\n\
                     To: alice@example.org\n\
                     Chat-Version: 1.0\n\
@@ -505,7 +512,7 @@ async fn test_is_bot() -> Result<()> {
 
     // Alice receives a message from Bob who is not the bot anymore.
     receive_imf(
-        alice,
+        &alice,
         b"From: Bob <bob@example.com>\n\
                     To: alice@example.org\n\
                     Chat-Version: 1.0\n\
@@ -519,7 +526,7 @@ async fn test_is_bot() -> Result<()> {
     let msg = alice.get_last_msg().await;
     assert_eq!(msg.get_text(), "hello again".to_string());
     assert!(!msg.is_bot());
-    let contact = Contact::get_by_id(alice, msg.from_id).await?;
+    let contact = Contact::get_by_id(&alice, msg.from_id).await?;
     assert!(!contact.is_bot());
 
     Ok(())

src/mimefactory.rs

@@ -35,10 +35,7 @@ use crate::peer_channels::{create_iroh_header, get_iroh_topic_for_msg};
 use crate::pgp::{SeipdVersion, addresses_from_public_key, pubkey_supports_seipdv2};
 use crate::simplify::escape_message_footer_marks;
 use crate::stock_str;
-use crate::tools::{
-    IsNoneOrEmpty, create_outgoing_rfc724_mid, create_smeared_timestamp, remove_subject_prefix,
-    time,
-};
+use crate::tools::{IsNoneOrEmpty, create_outgoing_rfc724_mid, remove_subject_prefix, time};
 use crate::webxdc::StatusUpdateSerial;
 
 // attachments of 25 mb brutto should work on the majority of providers
@@ -580,7 +577,7 @@ impl MimeFactory {
     ) -> Result<MimeFactory> {
         let contact = Contact::get_by_id(context, from_id).await?;
         let from_addr = context.get_primary_self_addr().await?;
-        let timestamp = create_smeared_timestamp(context);
+        let timestamp = time();
 
         let addr = contact.get_addr().to_string();
         let encryption_pubkeys = if from_id == ContactId::SELF {
@@ -2301,7 +2298,7 @@ pub(crate) async fn render_symm_encrypted_securejoin_message(
         mail_builder::headers::text::Text::new("Secure-Join".to_string()).into(),
     ));
 
-    let timestamp = create_smeared_timestamp(context);
+    let timestamp = time();
     let date = chrono::DateTime::<chrono::Utc>::from_timestamp(timestamp, 0)
         .unwrap()
         .to_rfc2822();

src/mimeparser.rs

@@ -31,9 +31,7 @@ use crate::message::{self, Message, MsgId, Viewtype, get_vcard_summary, set_msg_
 use crate::param::{Param, Params};
 use crate::simplify::{SimplifiedText, simplify};
 use crate::sync::SyncItems;
-use crate::tools::{
-    get_filemeta, parse_receive_headers, smeared_time, time, truncate_msg_text, validate_id,
-};
+use crate::tools::{get_filemeta, parse_receive_headers, time, truncate_msg_text, validate_id};
 use crate::{chatlist_events, location, tools};
 
 /// Public key extracted from `Autocrypt-Gossip`
@@ -271,7 +269,7 @@ impl MimeMessage {
     pub(crate) async fn from_bytes(context: &Context, body: &[u8]) -> Result<Self> {
         let mail = mailparse::parse_mail(body)?;
 
-        let timestamp_rcvd = smeared_time(context);
+        let timestamp_rcvd = time();
         let mut timestamp_sent =
             Self::get_timestamp_sent(&mail.headers, timestamp_rcvd, timestamp_rcvd);
         let hop_info = parse_receive_headers(&mail.get_headers());

src/mimeparser/mimeparser_tests.rs

@@ -1503,23 +1503,31 @@ Some reply
 // Test that WantsMdn parameter is not set on outgoing messages.
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_outgoing_wants_mdn() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let alice = &tcm.alice().await;
-    let alice2 = &tcm.alice().await;
-    let bob = &tcm.bob().await;
+    let alice = TestContext::new_alice().await;
+    let bob = TestContext::new_bob().await;
 
-    let chat_id = alice.create_chat(bob).await.id;
-    let sent = alice.send_text(chat_id, "Message.").await;
+    let raw = br"Date: Thu, 28 Jan 2021 00:26:57 +0000
+Chat-Version: 1.0\n\
+Message-ID: <foobarbaz@example.org>
+To: Bob <bob@example.org>
+From: Alice <alice@example.org>
+Subject: subject
+Chat-Disposition-Notification-To: alice@example.org
+
+Message.
+";
 
     // Bob receives message.
-    let bob_msg = bob.recv_msg(&sent).await;
+    receive_imf(&bob, raw, false).await?;
+    let msg = bob.get_last_msg().await;
     // Message is incoming.
-    assert!(bob_msg.param.get_bool(Param::WantsMdn).unwrap());
+    assert!(msg.param.get_bool(Param::WantsMdn).unwrap());
 
     // Alice receives copy-to-self.
-    let alice2_msg = alice2.recv_msg(&sent).await;
+    receive_imf(&alice, raw, false).await?;
+    let msg = alice.get_last_msg().await;
     // Message is outgoing, don't send read receipt to self.
-    assert!(alice2_msg.param.get_bool(Param::WantsMdn).is_none());
+    assert!(msg.param.get_bool(Param::WantsMdn).is_none());
 
     Ok(())
 }
@@ -1596,9 +1604,7 @@ async fn test_ignore_read_receipt_to_self() -> Result<()> {
 /// recognize it as MDN nevertheless to avoid displaying it in the chat as normal message.
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_ms_exchange_mdn() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let t = tcm.alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
+    let t = TestContext::new_alice().await;
 
     let original =
         include_bytes!("../../test-data/message/ms_exchange_report_original_message.eml");
@@ -2042,8 +2048,6 @@ async fn test_multiple_autocrypt_hdrs() -> Result<()> {
 async fn test_receive_signed_only() -> Result<()> {
     let mut tcm = TestContextManager::new();
     let bob = &tcm.bob().await;
-    bob.set_config(Config::ProcessUnencrypted, Some("1"))
-        .await?;
 
     let imf_raw = include_bytes!("../../test-data/message/unencrypted_signed_simple.eml");
     let msg = receive_imf(bob, imf_raw, false).await?.unwrap();

src/receive_imf.rs

@@ -505,11 +505,6 @@ pub(crate) async fn receive_imf_inner(
         Ok(mime_parser) => mime_parser,
     };
 
-    if !(mime_parser.was_encrypted() || mime_parser.get_header(HeaderDef::SecureJoin).is_some()) && !context.get_config_bool(Config::ProcessUnencrypted).await? {
-        warn!(context, "Fetched unencrypted message, ignoring");
-        return trash().await;
-    }
-
     let rfc724_mid_orig = &mime_parser
         .get_rfc724_mid()
         .unwrap_or(rfc724_mid.to_string());

src/receive_imf/receive_imf_tests.rs

@@ -100,9 +100,6 @@ async fn test_adhoc_group_is_shown() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_adhoc_group_show_accepted_contact_accepted() {
     let t = TestContext::new_alice().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true)
-        .await
-        .unwrap();
 
     // accept Bob by accepting a delta-message from Bob
     receive_imf(&t, MSGRMSG, false).await.unwrap();
@@ -157,9 +154,6 @@ async fn test_adhoc_group_show_all() {
 async fn test_adhoc_groups_merge() -> Result<()> {
     let mut tcm = TestContextManager::new();
     let alice = &tcm.alice().await;
-    alice
-        .set_config_bool(Config::ProcessUnencrypted, true)
-        .await?;
     receive_imf(
         alice,
         b"From: bob@example.net\n\
@@ -360,9 +354,6 @@ async fn test_no_message_id_header() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_escaped_from() {
     let t = TestContext::new_alice().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true)
-        .await
-        .unwrap();
     let contact_id = Contact::create(&t, "foobar", "foobar@example.com")
         .await
         .unwrap();
@@ -396,9 +387,6 @@ async fn test_escaped_from() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_escaped_recipients() {
     let t = TestContext::new_alice().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true)
-        .await
-        .unwrap();
     Contact::create(&t, "foobar", "foobar@example.com")
         .await
         .unwrap();
@@ -446,9 +434,6 @@ async fn test_escaped_recipients() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_cc_to_contact() {
     let t = TestContext::new_alice().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true)
-        .await
-        .unwrap();
     Contact::create(&t, "foobar", "foobar@example.com")
         .await
         .unwrap();
@@ -605,9 +590,6 @@ async fn test_parse_ndn(
 ) -> (TestContext, MsgId) {
     let t = TestContext::new().await;
     t.configure_addr(self_addr).await;
-    t.set_config(Config::ProcessUnencrypted, Some("1"))
-        .await
-        .unwrap();
 
     receive_imf(
         &t,
@@ -692,7 +674,6 @@ async fn test_resend_after_ndn() -> Result<()> {
 async fn test_parse_ndn_group_msg() -> Result<()> {
     let t = TestContext::new().await;
     t.configure_addr("alice@gmail.com").await;
-    t.set_config_bool(Config::ProcessUnencrypted, true).await?;
 
     receive_imf(
         &t,
@@ -734,7 +715,6 @@ async fn test_parse_ndn_group_msg() -> Result<()> {
 async fn test_concat_multiple_ndns() -> Result<()> {
     let t = TestContext::new().await;
     t.configure_addr("alice@posteo.org").await;
-    t.set_config_bool(Config::ProcessUnencrypted, true).await?;
     let mid = "1234@mail.gmail.com";
     receive_imf(
         &t,
@@ -792,9 +772,6 @@ async fn load_imf_email(context: &Context, imf_raw: &[u8]) -> Message {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_html_only_mail() {
     let t = TestContext::new_alice().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true)
-        .await
-        .unwrap();
     let msg = load_imf_email(&t, include_bytes!("../../test-data/message/wrong-html.eml")).await;
     assert_eq!(
         msg.text,
@@ -830,7 +807,6 @@ static GH_MAILINGLIST2: &str = "Received: (Postfix, from userid 1000); Mon, 4 De
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_github_mailing_list() -> Result<()> {
     let t = TestContext::new_alice().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true).await?;
 
     receive_imf(&t.ctx, GH_MAILINGLIST, false).await?;
 
@@ -904,8 +880,6 @@ static DC_MAILINGLIST2: &[u8] = b"Received: (Postfix, from userid 1000); Mon, 4
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_classic_mailing_list() -> Result<()> {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
-
     receive_imf(&t.ctx, DC_MAILINGLIST, false).await.unwrap();
     let chats = Chatlist::try_load(&t.ctx, 0, None, None).await.unwrap();
     let chat_id = chats.get_chat_id(0).unwrap();
@@ -947,8 +921,6 @@ Hello mailinglist!\r\n"
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_other_device_writes_to_mailinglist() -> Result<()> {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
-
     receive_imf(&t, DC_MAILINGLIST, false).await.unwrap();
     let first_msg = t.get_last_msg().await;
     let first_chat = Chat::load_from_db(&t, first_msg.chat_id).await?;
@@ -999,9 +971,6 @@ async fn test_other_device_writes_to_mailinglist() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_block_mailing_list() {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1"))
-        .await
-        .unwrap();
 
     receive_imf(&t.ctx, DC_MAILINGLIST, false).await.unwrap();
     t.evtracker.wait_next_incoming_message().await;
@@ -1036,9 +1005,6 @@ async fn test_block_mailing_list() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_mailing_list_decide_block_then_unblock() {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1"))
-        .await
-        .unwrap();
 
     receive_imf(&t, DC_MAILINGLIST, false).await.unwrap();
     let blocked = Contact::get_all_blocked(&t).await.unwrap();
@@ -1069,9 +1035,6 @@ async fn test_mailing_list_decide_block_then_unblock() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_mailing_list_decide_not_now() {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1"))
-        .await
-        .unwrap();
 
     receive_imf(&t.ctx, DC_MAILINGLIST, false).await.unwrap();
 
@@ -1099,9 +1062,6 @@ async fn test_mailing_list_decide_not_now() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_mailing_list_decide_accept() {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1"))
-        .await
-        .unwrap();
 
     receive_imf(&t.ctx, DC_MAILINGLIST, false).await.unwrap();
 
@@ -1124,8 +1084,6 @@ async fn test_mailing_list_decide_accept() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_mailing_list_multiple_names_in_subject() -> Result<()> {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
-
     receive_imf(
         &t,
         b"From: Foo Bar <foo@bar.org>\n\
@@ -1150,7 +1108,6 @@ async fn test_mailing_list_multiple_names_in_subject() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_majordomo_mailing_list() -> Result<()> {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
 
     // test mailing lists not having a `ListId:`-header
     receive_imf(
@@ -1203,7 +1160,6 @@ async fn test_majordomo_mailing_list() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_mailchimp_mailing_list() -> Result<()> {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
 
     receive_imf(
             &t,
@@ -1237,7 +1193,6 @@ async fn test_mailchimp_mailing_list() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_dhl_mailing_list() -> Result<()> {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
 
     receive_imf(
         &t,
@@ -1263,7 +1218,6 @@ async fn test_dhl_mailing_list() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_dpd_mailing_list() -> Result<()> {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
 
     receive_imf(
         &t,
@@ -1289,7 +1243,6 @@ async fn test_dpd_mailing_list() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_xt_local_mailing_list() -> Result<()> {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
 
     receive_imf(
         &t,
@@ -1323,7 +1276,6 @@ async fn test_xt_local_mailing_list() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_xing_mailing_list() -> Result<()> {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
 
     receive_imf(
         &t,
@@ -1346,7 +1298,6 @@ async fn test_xing_mailing_list() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_ttline_mailing_list() -> Result<()> {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
 
     receive_imf(
         &t,
@@ -1367,9 +1318,6 @@ async fn test_ttline_mailing_list() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_mailing_list_with_mimepart_footer() {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1"))
-        .await
-        .unwrap();
 
     // the mailing list message contains two top-level texts.
     // the second text is a footer that is added by some mailing list software
@@ -1397,9 +1345,6 @@ async fn test_mailing_list_with_mimepart_footer() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_mailing_list_with_mimepart_footer_signed() {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1"))
-        .await
-        .unwrap();
 
     receive_imf(
         &t,
@@ -1424,9 +1369,6 @@ async fn test_mailing_list_with_mimepart_footer_signed() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_apply_mailinglist_changes_assigned_by_reply() {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1"))
-        .await
-        .unwrap();
 
     receive_imf(&t, GH_MAILINGLIST, false).await.unwrap();
 
@@ -1465,9 +1407,6 @@ async fn test_apply_mailinglist_changes_assigned_by_reply() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_mailing_list_chat_message() {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1"))
-        .await
-        .unwrap();
 
     receive_imf(
         &t,
@@ -1490,9 +1429,6 @@ async fn test_mailing_list_chat_message() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_mailing_list_bot() {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1"))
-        .await
-        .unwrap();
     t.set_config(Config::Bot, Some("1")).await.unwrap();
 
     receive_imf(
@@ -1525,10 +1461,6 @@ async fn test_dont_show_noreply_in_contacts_list() {
 
 async fn check_dont_show_in_contacts_list(addr: &str) {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1"))
-        .await
-        .unwrap();
-
     receive_imf(
         &t,
         format!(
@@ -1558,9 +1490,6 @@ YEAAAAAA!.
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_pdf_filename_simple() {
     let t = TestContext::new_alice().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true)
-        .await
-        .unwrap();
     let msg = load_imf_email(
         &t,
         include_bytes!("../../test-data/message/pdf_filename_simple.eml"),
@@ -1581,9 +1510,6 @@ async fn test_pdf_filename_simple() {
 async fn test_pdf_filename_continuation() {
     // test filenames split across multiple header lines, see rfc 2231
     let t = TestContext::new_alice().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true)
-        .await
-        .unwrap();
     let msg = load_imf_email(
         &t,
         include_bytes!("../../test-data/message/pdf_filename_continuation.eml"),
@@ -1609,9 +1535,6 @@ async fn test_pdf_filename_continuation() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_many_images() {
     let t = TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1"))
-        .await
-        .unwrap();
 
     receive_imf(
         &t,
@@ -1632,9 +1555,6 @@ async fn test_many_images() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_in_reply_to() {
     let t = TestContext::new().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1"))
-        .await
-        .unwrap();
     t.configure_addr("bob@example.com").await;
 
     // Receive message from Alice about group "foo".
@@ -1712,10 +1632,6 @@ async fn test_save_mime_headers_off() -> anyhow::Result<()> {
 async fn check_alias_reply(from_dc: bool, chat_request: bool, group_request: bool) {
     let mut tcm = TestContextManager::new();
     let alice = tcm.alice().await;
-    alice
-        .set_config_bool(Config::ProcessUnencrypted, true)
-        .await
-        .unwrap();
 
     // Claire, a customer, sends a support request
     // to the alias address <support@example.org>.
@@ -1782,11 +1698,6 @@ async fn check_alias_reply(from_dc: bool, chat_request: bool, group_request: boo
 
     let claire = tcm.unconfigured().await;
     claire.configure_addr("claire@example.org").await;
-    claire
-        .set_config_bool(Config::ProcessUnencrypted, true)
-        .await
-        .unwrap();
-
     receive_imf(&claire, claire_request.as_bytes(), false)
         .await
         .unwrap();
@@ -2001,7 +1912,6 @@ Message content",
 async fn test_unencrypted_doesnt_goto_self_chat() -> Result<()> {
     let mut tcm = TestContextManager::new();
     let t = &tcm.alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
     let mut chat_id = None;
 
     for (i, to) in [
@@ -2083,10 +1993,6 @@ async fn test_no_smtp_job_for_self_chat() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_outgoing_classic_mail_creates_chat() {
     let alice = TestContext::new_alice().await;
-    alice
-        .set_config(Config::ProcessUnencrypted, Some("1"))
-        .await
-        .unwrap();
 
     // Alice downloads outgoing classic email.
     receive_imf(
@@ -2112,9 +2018,6 @@ Message content",
 async fn test_duplicate_message() -> Result<()> {
     // Test that duplicate messages are ignored based on the Message-ID
     let alice = TestContext::new_alice().await;
-    alice
-        .set_config_bool(Config::ProcessUnencrypted, true)
-        .await?;
 
     let bob_contact_id = Contact::add_or_lookup(
         &alice,
@@ -2173,8 +2076,6 @@ Second signature";
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_ignore_footer_status_from_mailinglist() -> Result<()> {
     let t = TestContext::new_alice().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true).await?;
-
     let bob_id = Contact::add_or_lookup(
         &t,
         "",
@@ -2254,8 +2155,6 @@ Original signature updated",
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_ignore_old_status_updates() -> Result<()> {
     let t = TestContext::new_alice().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true).await?;
-
     let bob_id = Contact::add_or_lookup(
         &t,
         "",
@@ -2325,15 +2224,11 @@ sig thursday",
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_chat_assignment_private_classical_reply() {
-    let mut tcm = TestContextManager::new();
     for outgoing_is_classical in &[true, false] {
-        let t = &tcm.alice().await;
-        t.set_config_bool(Config::ProcessUnencrypted, true)
-            .await
-            .unwrap();
+        let t = TestContext::new_alice().await;
 
         receive_imf(
-            t,
+            &t,
             format!(
                 r#"Received: from mout.gmx.net (mout.gmx.net [212.227.17.22])
 Subject: =?utf-8?q?single_reply-to?=
@@ -2375,7 +2270,7 @@ Message-ID: <Gr.eJ_llQIXf0K.buxmrnMmG0Y@gmx.de>"
         assert_eq!(group_chat.name, "single reply-to");
 
         receive_imf(
-            t,
+            &t,
             format!(
                 r#"Subject: Re: single reply-to
 To: "Alice" <alice@example.org>
@@ -2507,12 +2402,8 @@ Sent with my Delta Chat Messenger: https://delta.chat
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_chat_assignment_nonprivate_classical_reply() {
-    let mut tcm = TestContextManager::new();
     for outgoing_is_classical in &[true, false] {
-        let t = &tcm.alice().await;
-        t.set_config_bool(Config::ProcessUnencrypted, true)
-            .await
-            .unwrap();
+        let t = TestContext::new_alice().await;
 
         receive_imf(
             &t,
@@ -2557,7 +2448,7 @@ Message-ID: <Gr.eJ_llQIXf0K.buxmrnMmG0Y@gmx.de>"
 
         // =============== Receive another outgoing message and check that it is put into the same chat ===============
         receive_imf(
-            t,
+            &t,
             format!(
                 r#"Received: from mout.gmx.net (mout.gmx.net [212.227.17.22])
 Subject: Out subj
@@ -2767,7 +2658,6 @@ async fn test_read_receipts_dont_unmark_bots() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_gmx_forwarded_msg() -> Result<()> {
     let t = TestContext::new_alice().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true).await?;
 
     receive_imf(
         &t,
@@ -3363,9 +3253,6 @@ async fn test_blocked_contact_creates_group() -> Result<()> {
 async fn test_outgoing_undecryptable() -> Result<()> {
     let alice = &TestContext::new().await;
     alice.configure_addr("alice@example.org").await;
-    alice
-        .set_config(Config::ProcessUnencrypted, Some("1"))
-        .await?;
 
     let raw = include_bytes!("../../test-data/message/thunderbird_with_autocrypt.eml");
     receive_imf(alice, raw, false).await?;
@@ -3402,7 +3289,6 @@ async fn test_outgoing_undecryptable() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_thunderbird_autocrypt() -> Result<()> {
     let t = TestContext::new_bob().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true).await?;
 
     let raw = include_bytes!("../../test-data/message/thunderbird_with_autocrypt.eml");
     let received_msg = receive_imf(&t, raw, false).await?.unwrap();
@@ -3450,7 +3336,6 @@ async fn test_issuer_fingerprint() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_prefer_encrypt_mutual_if_encrypted() -> Result<()> {
     let t = TestContext::new_bob().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true).await?;
 
     // The message has public key attached *and* Autocrypt header.
     //
@@ -3522,9 +3407,6 @@ async fn test_forged_from_and_no_valid_signatures() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_wrong_from_name_and_no_valid_signatures() -> Result<()> {
     let t = &TestContext::new_bob().await;
-    // TODO: same test, but with ProcessUnencrypted, should trash the message
-    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
-
     let raw = include_bytes!("../../test-data/message/thunderbird_encrypted_signed.eml");
     let raw = String::from_utf8(raw.to_vec())?.replace("From: Alice", "From: A");
     receive_imf(t, raw.as_bytes(), false).await?.unwrap();
@@ -3539,8 +3421,6 @@ async fn test_wrong_from_name_and_no_valid_signatures() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_thunderbird_autocrypt_unencrypted() -> Result<()> {
     let bob = &TestContext::new_bob().await;
-    bob.set_config(Config::ProcessUnencrypted, Some("1"))
-        .await?;
 
     // Thunderbird message with Autocrypt header and a signature,
     // but not encrypted.
@@ -3579,11 +3459,6 @@ async fn test_thunderbird_autocrypt_unencrypted() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_thunderbird_unsigned() -> Result<()> {
     let alice = TestContext::new_alice().await;
-    // TODO: same test without process unencrypted should trash the message
-    alice
-        .set_config(Config::ProcessUnencrypted, Some("1"))
-        .await
-        .unwrap();
 
     // Alice receives an unsigned message from Bob.
     let raw = include_bytes!("../../test-data/message/thunderbird_encrypted_unsigned.eml");
@@ -3693,7 +3568,6 @@ async fn test_big_forwarded_with_big_attachment() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_mua_user_adds_member() -> Result<()> {
     let t = TestContext::new_alice().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true).await?;
 
     receive_imf(
         &t,
@@ -3745,9 +3619,6 @@ async fn test_mua_user_adds_member() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_mua_user_adds_recipient_to_single_chat() -> Result<()> {
     let alice = TestContext::new_alice().await;
-    alice
-        .set_config_bool(Config::ProcessUnencrypted, true)
-        .await?;
 
     // Alice sends a 1:1 message to Bob, creating a 1:1 chat.
     let msg = receive_imf(
@@ -4104,6 +3975,8 @@ async fn test_delayed_removal_is_ignored() -> Result<()> {
     remove_contact_from_chat(bob, bob_chat_id, bob_contact_fiona).await?;
     let remove_msg = bob.pop_sent_msg().await;
 
+    SystemTime::shift(Duration::from_secs(1));
+
     // Bob adds new members Dom and Elena, but first addition message is lost.
     let dom = &tcm.dom().await;
     let elena = &tcm.elena().await;
@@ -4120,6 +3993,8 @@ async fn test_delayed_removal_is_ignored() -> Result<()> {
     alice.recv_msg(&add_msg).await;
     assert_eq!(get_chat_contacts(alice, chat_id).await?.len(), 4);
 
+    SystemTime::shift(Duration::from_secs(1));
+
     // Alice re-adds Fiona.
     add_contact_to_chat(alice, chat_id, alice_fiona).await?;
     assert_eq!(get_chat_contacts(alice, chat_id).await?.len(), 5);
@@ -4180,9 +4055,6 @@ async fn test_dont_readd_with_normal_msg() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_mua_cant_remove() -> Result<()> {
     let alice = TestContext::new_alice().await;
-    alice
-        .set_config_bool(Config::ProcessUnencrypted, true)
-        .await?;
 
     let now = time();
 
@@ -4275,9 +4147,6 @@ async fn test_mua_cant_remove() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_mua_can_add() -> Result<()> {
     let alice = TestContext::new_alice().await;
-    alice
-        .set_config(Config::ProcessUnencrypted, Some("1"))
-        .await?;
 
     let now = time();
 
@@ -4337,9 +4206,6 @@ async fn test_mua_can_add() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_mua_can_readd() -> Result<()> {
     let alice = TestContext::new_alice().await;
-    alice
-        .set_config_bool(Config::ProcessUnencrypted, true)
-        .await?;
 
     // Alice creates chat with 3 contacts.
     let msg = receive_imf(
@@ -4503,10 +4369,6 @@ async fn test_keep_member_list_if_possibly_nomember() -> Result<()> {
 async fn test_adhoc_grp_name_no_prefix() -> Result<()> {
     let mut tcm = TestContextManager::new();
     let alice = &tcm.alice().await;
-    alice
-        .set_config(Config::ProcessUnencrypted, Some("1"))
-        .await?;
-
     let chat_id = receive_imf(
         alice,
         b"Subject: Re: Once upon a time this was with the only Re: here\n\
@@ -4542,12 +4404,12 @@ async fn test_outgoing_msg_forgery() -> Result<()> {
     imex(alice, ImexMode::ExportSelfKeys, export_dir.path(), None).await?;
     // We need Bob only to encrypt the forged message to Alice's key, actually Bob doesn't
     // participate in the scenario.
-    let bob = &tcm.unconfigured().await;
+    let bob = &TestContext::new().await;
     assert_eq!(crate::key::load_self_secret_keyring(bob).await?.len(), 0);
     bob.configure_addr("bob@example.net").await;
     imex(bob, ImexMode::ImportSelfKeys, export_dir.path(), None).await?;
     assert_eq!(crate::key::load_self_secret_keyring(bob).await?.len(), 1);
-    let malice = &tcm.unconfigured().await;
+    let malice = &TestContext::new().await;
     malice.configure_addr(alice_addr).await;
 
     let malice_chat_id = tcm
@@ -4789,7 +4651,6 @@ async fn test_forged_from() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_multiline_iso_8859_1_subject() -> Result<()> {
     let t = &TestContext::new_alice().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true).await?;
     let mail = b"Received: (Postfix, from userid 1000); Mon, 4 Dec 2006 14:51:39 +0100 (CET)\n\
         From: bob@example.com\n\
         To: alice@example.org, claire@example.com\n\
@@ -4854,7 +4715,6 @@ async fn test_references() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_list_from() -> Result<()> {
     let t = &TestContext::new_alice().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true).await?;
 
     let raw = include_bytes!("../../test-data/message/list-from.eml");
     let received = receive_imf(t, raw, false).await?.unwrap();
@@ -4984,7 +4844,6 @@ async fn test_make_n_send_vcard() -> Result<()> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_unencrypted_group_id_no_recipients() -> Result<()> {
     let t = &TestContext::new_alice().await;
-    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
     let raw = "From: alice@example.org
 Subject: Group
 Chat-Version: 1.0
@@ -5458,9 +5317,6 @@ async fn test_outgoing_unencrypted_chat_assignment() {
 async fn test_incoming_reply_with_date_in_past() -> Result<()> {
     let mut tcm = TestContextManager::new();
     let alice = &tcm.alice().await;
-    alice
-        .set_config_bool(Config::ProcessUnencrypted, true)
-        .await?;
 
     let msg0 = receive_imf(
         alice,
@@ -5602,11 +5458,6 @@ async fn test_small_unencrypted_group() -> Result<()> {
     let mut tcm = TestContextManager::new();
     let alice = &tcm.alice().await;
     let bob = &tcm.bob().await;
-    alice
-        .set_config(Config::ProcessUnencrypted, Some("1"))
-        .await?;
-    bob.set_config(Config::ProcessUnencrypted, Some("1"))
-        .await?;
 
     let alice_chat_id = chat::create_group_unencrypted(alice, "Unencrypted group").await?;
     let alice_bob_id = alice.add_or_lookup_address_contact_id(bob).await;
@@ -5686,7 +5537,6 @@ async fn test_lookup_key_contact_by_address_self() -> Result<()> {
 async fn test_calendar_alternative() -> Result<()> {
     let mut tcm = TestContextManager::new();
     let t = &tcm.alice().await;
-    t.set_config_bool(Config::ProcessUnencrypted, true).await?;
     let raw = include_bytes!("../../test-data/message/calendar-alternative.eml");
     let msg = receive_imf(t, raw, false).await?.unwrap();
     assert_eq!(msg.msg_ids.len(), 1);

src/securejoin/bob.rs

@@ -19,7 +19,7 @@ use crate::securejoin::{
 };
 use crate::stock_str;
 use crate::sync::Sync::*;
-use crate::tools::{create_outgoing_rfc724_mid, smeared_time, time};
+use crate::tools::{create_outgoing_rfc724_mid, time};
 use crate::{chatlist_events, mimefactory};
 
 /// Starts the securejoin protocol with the QR `invite`.
@@ -465,7 +465,7 @@ async fn joining_chat_id(
                         name,
                         Blocked::Not,
                         None,
-                        smeared_time(context),
+                        time(),
                     )
                     .await?
                 }

src/securejoin/securejoin_tests.rs

@@ -772,9 +772,6 @@ fn manipulate_qr(v3: bool, remove_invite: bool, qr: &mut String) {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_adhoc_group_no_qr() -> Result<()> {
     let alice = TestContext::new_alice().await;
-    alice
-        .set_config_bool(Config::ProcessUnencrypted, true)
-        .await?;
 
     let mime = br#"Subject: First thread
 Message-ID: first@example.org
@@ -1418,9 +1415,6 @@ async fn test_vc_request_encrypted_at_rest() -> Result<()> {
     let mut tcm = TestContextManager::new();
     let alice = &tcm.alice().await;
     let bob = &tcm.bob().await;
-    alice
-        .set_config_bool(Config::ProcessUnencrypted, true)
-        .await?;
 
     let qr = get_securejoin_qr(alice, None).await?;
 

src/test_utils.rs

@@ -20,7 +20,6 @@ use pretty_assertions::assert_eq;
 use tempfile::{TempDir, tempdir};
 use tokio::runtime::Handle;
 use tokio::{fs, task};
-use uuid::Uuid;
 
 use crate::chat::{
     self, Chat, ChatId, ChatIdBlocked, MessageListOptions, add_to_chat_contacts_table, create_group,
@@ -33,14 +32,12 @@ use crate::contact::{
     Contact, ContactId, Modifier, Origin, import_vcard, make_vcard, mark_contact_id_as_verified,
 };
 use crate::context::Context;
-use crate::e2ee::EncryptHelper;
 use crate::events::{Event, EventEmitter, EventType, Events};
 use crate::key::{self, DcKey, self_fingerprint};
 use crate::log::warn;
 use crate::login_param::EnteredLoginParam;
 use crate::message::{Message, MessageState, MsgId, update_msg_state};
 use crate::mimeparser::{MimeMessage, SystemMessage};
-use crate::pgp::SeipdVersion;
 use crate::receive_imf::receive_imf;
 use crate::securejoin::{get_securejoin_qr, join_securejoin};
 use crate::smtp::msg_has_pending_smtp_job;
@@ -1217,53 +1214,6 @@ ORDER BY id"
     }
 }
 
-pub async fn encrypt_raw_message(
-    context: &Context,
-    receivers: &[&TestContext],
-    payload: &[u8],
-) -> Result<String> {
-    let encryption_helper = EncryptHelper::new(context).await?;
-    let mut encryption_keyring = vec![encryption_helper.public_key.clone()];
-
-    for receiver in receivers {
-        encryption_keyring.push(key::load_self_public_key(receiver).await?);
-    }
-
-    let from = context.get_primary_self_addr().await?;
-    let compress = false;
-    let encrypted_payload = encryption_helper
-        .encrypt_raw(
-            context,
-            encryption_keyring,
-            payload.to_vec(),
-            compress,
-            SeipdVersion::V2,
-        )
-        .await?;
-    let boundary = Uuid::new_v4();
-
-    let res = format!(
-"Content-Type: multipart/encrypted; protocol=\"application/pgp-encrypted\"; boundary=\"{boundary}\"\r
-MIME-Version: 1.0\r
-From: {from}\r
-Subject: [...]\r
-\r
-\r
---{boundary}
-Content-Type: application/pgp-encrypted\r
-\r
-Version: 1\r
-\r
---{boundary}\r
-Content-Type: application/octet-stream\r
-\r
-{encrypted_payload}
-\r
---{boundary}--
-");
-    Ok(res)
-}
-
 impl Deref for TestContext {
     type Target = Context;
 

src/tests/verified_chats.rs

@@ -332,7 +332,6 @@ async fn test_reply() -> Result<()> {
         let mut tcm = TestContextManager::new();
         let alice = tcm.alice().await;
         let bob = tcm.bob().await;
-        alice.set_config(Config::ProcessUnencrypted, Some("1")).await?;
 
         if verified {
             mark_as_verified(&alice, &bob).await;

src/timesmearing.rs

@@ -1,194 +0,0 @@
-//! # Time smearing.
-//!
-//! As e-mails typically only use a second-based-resolution for timestamps,
-//! the order of two mails sent within one second is unclear.
-//! This is bad e.g. when forwarding some messages from a chat -
-//! these messages will appear at the recipient easily out of order.
-//!
-//! We work around this issue by not sending out two mails with the same timestamp.
-//! For this purpose, in short, we track the last timestamp used in `last_smeared_timestamp`
-//! when another timestamp is needed in the same second, we use `last_smeared_timestamp+1`
-//! after some moments without messages sent out,
-//! `last_smeared_timestamp` is again in sync with the normal time.
-//!
-//! However, we do not do all this for the far future,
-//! but at max `MAX_SECONDS_TO_LEND_FROM_FUTURE`
-
-use std::cmp::{max, min};
-use std::sync::atomic::{AtomicI64, Ordering};
-
-pub(crate) const MAX_SECONDS_TO_LEND_FROM_FUTURE: i64 = 30;
-
-/// Smeared timestamp generator.
-#[derive(Debug)]
-pub struct SmearedTimestamp {
-    /// Next timestamp available for allocation.
-    smeared_timestamp: AtomicI64,
-}
-
-impl SmearedTimestamp {
-    /// Creates a new smeared timestamp generator.
-    pub fn new() -> Self {
-        Self {
-            smeared_timestamp: AtomicI64::new(0),
-        }
-    }
-
-    /// Allocates `count` unique timestamps.
-    ///
-    /// Returns the first allocated timestamp.
-    #[expect(clippy::arithmetic_side_effects)]
-    pub fn create_n(&self, now: i64, count: i64) -> i64 {
-        let mut prev = self.smeared_timestamp.load(Ordering::Relaxed);
-        loop {
-            // Advance the timestamp if it is in the past,
-            // but keep `count - 1` timestamps from the past if possible.
-            let t = max(prev, now - count + 1);
-
-            // Rewind the time back if there is no room
-            // to allocate `count` timestamps without going too far into the future.
-            // Not going too far into the future
-            // is more important than generating unique timestamps.
-            let first = min(t, now + MAX_SECONDS_TO_LEND_FROM_FUTURE - count + 1);
-
-            // Allocate `count` timestamps by advancing the current timestamp.
-            let next = first + count;
-
-            if let Err(x) = self.smeared_timestamp.compare_exchange_weak(
-                prev,
-                next,
-                Ordering::Relaxed,
-                Ordering::Relaxed,
-            ) {
-                prev = x;
-            } else {
-                return first;
-            }
-        }
-    }
-
-    /// Creates a single timestamp.
-    pub fn create(&self, now: i64) -> i64 {
-        self.create_n(now, 1)
-    }
-
-    /// Returns the current smeared timestamp.
-    pub fn current(&self) -> i64 {
-        self.smeared_timestamp.load(Ordering::Relaxed)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::test_utils::TestContext;
-    use crate::tools::{
-        SystemTime, create_smeared_timestamp, create_smeared_timestamps, smeared_time, time,
-    };
-
-    #[test]
-    fn test_smeared_timestamp() {
-        let smeared_timestamp = SmearedTimestamp::new();
-        let now = time();
-
-        assert_eq!(smeared_timestamp.current(), 0);
-
-        for i in 0..MAX_SECONDS_TO_LEND_FROM_FUTURE {
-            assert_eq!(smeared_timestamp.create(now), now + i);
-        }
-        assert_eq!(
-            smeared_timestamp.create(now),
-            now + MAX_SECONDS_TO_LEND_FROM_FUTURE
-        );
-        assert_eq!(
-            smeared_timestamp.create(now),
-            now + MAX_SECONDS_TO_LEND_FROM_FUTURE
-        );
-
-        // System time rewinds back by 1000 seconds.
-        let now = now - 1000;
-        assert_eq!(
-            smeared_timestamp.create(now),
-            now + MAX_SECONDS_TO_LEND_FROM_FUTURE
-        );
-        assert_eq!(
-            smeared_timestamp.create(now),
-            now + MAX_SECONDS_TO_LEND_FROM_FUTURE
-        );
-        assert_eq!(
-            smeared_timestamp.create(now + 1),
-            now + MAX_SECONDS_TO_LEND_FROM_FUTURE + 1
-        );
-        assert_eq!(smeared_timestamp.create(now + 100), now + 100);
-        assert_eq!(smeared_timestamp.create(now + 100), now + 101);
-        assert_eq!(smeared_timestamp.create(now + 100), now + 102);
-    }
-
-    #[test]
-    fn test_create_n_smeared_timestamps() {
-        let smeared_timestamp = SmearedTimestamp::new();
-        let now = time();
-
-        // Create a single timestamp to initialize the generator.
-        assert_eq!(smeared_timestamp.create(now), now);
-
-        // Wait a minute.
-        let now = now + 60;
-
-        // Simulate forwarding 7 messages.
-        let forwarded_messages = 7;
-
-        // We have not sent anything for a minute,
-        // so we can take the current timestamp and take 6 timestamps from the past.
-        assert_eq!(smeared_timestamp.create_n(now, forwarded_messages), now - 6);
-
-        assert_eq!(smeared_timestamp.current(), now + 1);
-
-        // Wait 4 seconds.
-        // Now we have 3 free timestamps in the past.
-        let now = now + 4;
-
-        assert_eq!(smeared_timestamp.current(), now - 3);
-
-        // Forward another 7 messages.
-        // We can only lend 3 timestamps from the past.
-        assert_eq!(smeared_timestamp.create_n(now, forwarded_messages), now - 3);
-
-        // We had to borrow 3 timestamps from the future
-        // because there were not enough timestamps in the past.
-        assert_eq!(smeared_timestamp.current(), now + 4);
-
-        // Forward another 32 messages.
-        // We cannot use more than 30 timestamps from the future,
-        // so we use 30 timestamps from the future,
-        // the current timestamp and one timestamp from the past.
-        assert_eq!(smeared_timestamp.create_n(now, 32), now - 1);
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_create_smeared_timestamp() {
-        let t = TestContext::new().await;
-        assert_ne!(create_smeared_timestamp(&t), create_smeared_timestamp(&t));
-        assert!(
-            create_smeared_timestamp(&t)
-                >= SystemTime::now()
-                    .duration_since(SystemTime::UNIX_EPOCH)
-                    .unwrap()
-                    .as_secs() as i64
-        );
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_create_smeared_timestamps() {
-        let t = TestContext::new().await;
-        let count = MAX_SECONDS_TO_LEND_FROM_FUTURE - 1;
-        let start = create_smeared_timestamps(&t, count as usize);
-        let next = smeared_time(&t);
-        assert!((start + count - 1) < next);
-
-        let count = MAX_SECONDS_TO_LEND_FROM_FUTURE + 30;
-        let start = create_smeared_timestamps(&t, count as usize);
-        let next = smeared_time(&t);
-        assert!((start + count - 1) < next);
-    }
-}

src/tools.rs

@@ -180,29 +180,6 @@ pub(crate) fn gm2local_offset() -> i64 {
     i64::from(lt.offset().local_minus_utc())
 }
 
-/// Returns the current smeared timestamp,
-///
-/// The returned timestamp MAY NOT be unique and MUST NOT go to "Date" header.
-pub(crate) fn smeared_time(context: &Context) -> i64 {
-    let now = time();
-    let ts = context.smeared_timestamp.current();
-    std::cmp::max(ts, now)
-}
-
-/// Returns a timestamp that is guaranteed to be unique.
-pub(crate) fn create_smeared_timestamp(context: &Context) -> i64 {
-    let now = time();
-    context.smeared_timestamp.create(now)
-}
-
-// creates `count` timestamps that are guaranteed to be unique.
-// the first created timestamps is returned directly,
-// get the other timestamps just by adding 1..count-1
-pub(crate) fn create_smeared_timestamps(context: &Context, count: usize) -> i64 {
-    let now = time();
-    context.smeared_timestamp.create_n(now, count as i64)
-}
-
 /// Returns the last release timestamp as a unix timestamp compatible for comparison with time() and
 /// database times.
 pub fn get_release_timestamp() -> i64 {

src/webxdc.rs

@@ -46,7 +46,7 @@ use crate::mimefactory::RECOMMENDED_FILE_SIZE;
 use crate::mimeparser::SystemMessage;
 use crate::param::Param;
 use crate::param::Params;
-use crate::tools::{create_id, create_smeared_timestamp, get_abs_path};
+use crate::tools::{create_id, get_abs_path, time};
 
 /// The current API version.
 /// If `min_api` in manifest.toml is set to a larger value,
@@ -558,7 +558,7 @@ impl Context {
             .create_status_update_record(
                 &instance,
                 status_update,
-                create_smeared_timestamp(self),
+                time(),
                 send_now,
                 ContactId::SELF,
             )

src/webxdc/webxdc_tests.rs

@@ -983,7 +983,7 @@ async fn test_pop_status_update() -> Result<()> {
 async fn test_draft_and_send_webxdc_status_update() -> Result<()> {
     let alice = TestContext::new_alice().await;
     let bob = TestContext::new_bob().await;
-    let alice_chat_id = alice.create_chat(&bob).await.id;
+    let alice_chat_id = alice.create_email_chat(&bob).await.id;
 
     // prepare webxdc instance,
     // status updates are not sent for drafts, therefore send_webxdc_status_update() returns Ok(None)
@@ -1030,6 +1030,8 @@ async fn test_draft_and_send_webxdc_status_update() -> Result<()> {
     let bob_instance = bob.recv_msg(&sent1).await;
     assert_eq!(bob_instance.viewtype, Viewtype::Webxdc);
     assert_eq!(bob_instance.get_filename().unwrap(), "minimal.xdc");
+    assert!(sent1.payload().contains("Content-Type: application/json"));
+    assert!(sent1.payload().contains("status-update.json"));
     assert_eq!(
         bob.get_webxdc_status_updates(bob_instance.id, StatusUpdateSerial(0))
             .await?,

test-data/golden/test_sync_broadcast_alice1

@@ -1,7 +1,7 @@
 OutBroadcast#Chat#1001: Channel [0 member(s)]
 --------------------------------------------------------------------------------
 Msg#1001: info (Contact#Contact#Info): Messages are end-to-end encrypted. [NOTICED][INFO]
-Msg#1008🔒: Me (Contact#Contact#Self): hi  √
 Msg#1006🔒: Me (Contact#Contact#Self): Member bob@example.net added. [INFO] √
+Msg#1008🔒: Me (Contact#Contact#Self): hi  √
 Msg#1009🔒: Me (Contact#Contact#Self): You removed member bob@example.net. [INFO] √
 --------------------------------------------------------------------------------