From c0deb83206602597bee519f56526df680fb44bb5 Mon Sep 17 00:00:00 2001 From: link2xt Date: Thu, 7 May 2026 07:10:17 +0200 Subject: [PATCH] WIP: feat: add option to process unencrypted messages --- src/chat/chat_tests.rs | 98 ++++++++-------- src/chatlist.rs | 3 + src/config.rs | 5 + src/context.rs | 6 + src/decrypt.rs | 3 + src/e2ee.rs | 2 + src/html.rs | 28 ++++- src/imap.rs | 11 +- src/imap/session.rs | 1 + src/location.rs | 4 +- src/message/message_tests.rs | 33 +++--- src/mimeparser/mimeparser_tests.rs | 34 +++--- src/receive_imf.rs | 5 + src/receive_imf/receive_imf_tests.rs | 168 +++++++++++++++++++++++++-- src/securejoin/securejoin_tests.rs | 6 + src/tests/verified_chats.rs | 1 + src/webxdc/webxdc_tests.rs | 4 +- 17 files changed, 309 insertions(+), 103 deletions(-) diff --git a/src/chat/chat_tests.rs b/src/chat/chat_tests.rs index 162768059..1e876a56a 100644 --- a/src/chat/chat_tests.rs +++ b/src/chat/chat_tests.rs @@ -1049,6 +1049,7 @@ 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) @@ -1381,6 +1382,9 @@ 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, @@ -1873,45 +1877,38 @@ async fn test_lookup_self_by_contact_id() { #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn test_marknoticed_chat() -> Result<()> { - let t = TestContext::new_alice().await; - let chat = t.create_chat_with_contact("bob", "bob@example.org").await; + let mut tcm = TestContextManager::new(); + let alice = &tcm.alice().await; + let bob = &tcm.bob().await; + let chat = alice.create_chat(bob).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 bob_chat_id = bob.create_chat_id(alice).await; + let sent = bob.send_text(bob_chat_id, "hello").await; + alice.recv_msg(&sent).await; - let chats = Chatlist::try_load(&t, 0, None, None).await?; + let chats = Chatlist::try_load(alice, 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(&t).await?, 1); - assert_eq!(t.get_fresh_msgs().await?.len(), 1); + assert_eq!(chat.id.get_fresh_msg_cnt(alice).await?, 1); + assert_eq!(alice.get_fresh_msgs().await?.len(), 1); - let msgs = get_chat_msgs(&t, chat.id).await?; - assert_eq!(msgs.len(), 1); - let msg_id = match msgs.first().unwrap() { + let msgs = get_chat_msgs(alice, chat.id).await?; + assert_eq!(msgs.len(), 2); + let msg_id = match msgs.last().unwrap() { ChatItem::Message { msg_id } => *msg_id, _ => MsgId::new_unset(), }; - let msg = message::Message::load_from_db(&t, msg_id).await?; + let msg = message::Message::load_from_db(alice, msg_id).await?; assert_eq!(msg.state, MessageState::InFresh); - marknoticed_chat(&t, chat.id).await?; + marknoticed_chat(alice, chat.id).await?; - let chats = Chatlist::try_load(&t, 0, None, None).await?; + let chats = Chatlist::try_load(alice, 0, None, None).await?; assert_eq!(chats.len(), 1); - let msg = message::Message::load_from_db(&t, msg_id).await?; + let msg = message::Message::load_from_db(alice, msg_id).await?; assert_eq!(msg.state, MessageState::InNoticed); - assert_eq!(chat.id.get_fresh_msg_cnt(&t).await?, 0); - assert_eq!(t.get_fresh_msgs().await?.len(), 0); + assert_eq!(chat.id.get_fresh_msg_cnt(alice).await?, 0); + assert_eq!(alice.get_fresh_msgs().await?.len(), 0); Ok(()) } @@ -1919,6 +1916,7 @@ 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); @@ -1970,40 +1968,43 @@ async fn test_contact_request_fresh_messages() -> Result<()> { #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn test_contact_request_archive() -> Result<()> { - let t = TestContext::new_alice().await; + let mut tcm = TestContextManager::new(); + let alice = &tcm.alice().await; + let bob = &tcm.bob().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 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; - let chats = Chatlist::try_load(&t, 0, None, None).await?; + let chats = Chatlist::try_load(alice, 0, None, None).await?; assert_eq!(chats.len(), 1); let chat_id = chats.get_chat_id(0)?; - assert!(Chat::load_from_db(&t, chat_id).await?.is_contact_request()); - assert_eq!(get_archived_cnt(&t).await?, 0); + assert!( + Chat::load_from_db(alice, chat_id) + .await? + .is_contact_request() + ); + assert_eq!(get_archived_cnt(alice).await?, 0); // archive request without accepting or blocking - chat_id.set_visibility(&t, ChatVisibility::Archived).await?; + chat_id + .set_visibility(alice, ChatVisibility::Archived) + .await?; - let chats = Chatlist::try_load(&t, 0, None, None).await?; + let chats = Chatlist::try_load(alice, 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(&t).await?, 1); + assert_eq!(get_archived_cnt(alice).await?, 1); - let chats = Chatlist::try_load(&t, DC_GCL_ARCHIVED_ONLY, None, None).await?; + let chats = Chatlist::try_load(alice, 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(&t, chat_id).await?.is_contact_request()); + assert!( + Chat::load_from_db(alice, chat_id) + .await? + .is_contact_request() + ); Ok(()) } @@ -2011,6 +2012,9 @@ 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( diff --git a/src/chatlist.rs b/src/chatlist.rs index 534dccf91..ccb36d40c 100644 --- a/src/chatlist.rs +++ b/src/chatlist.rs @@ -473,6 +473,7 @@ 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; @@ -665,6 +666,7 @@ 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( @@ -725,6 +727,7 @@ 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( diff --git a/src/config.rs b/src/config.rs index f0ca2fafb..447b47f92 100644 --- a/src/config.rs +++ b/src/config.rs @@ -486,6 +486,11 @@ 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 { diff --git a/src/context.rs b/src/context.rs index 95ce3c777..ff559fb86 100644 --- a/src/context.rs +++ b/src/context.rs @@ -1056,6 +1056,12 @@ 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)); diff --git a/src/decrypt.rs b/src/decrypt.rs index 21fd3d3cf..8716f23a8 100644 --- a/src/decrypt.rs +++ b/src/decrypt.rs @@ -370,6 +370,7 @@ 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<()> { @@ -402,6 +403,7 @@ 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". @@ -416,6 +418,7 @@ 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()); diff --git a/src/e2ee.rs b/src/e2ee.rs index 9a1f639bf..333fa056e 100644 --- a/src/e2ee.rs +++ b/src/e2ee.rs @@ -147,6 +147,8 @@ 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\ diff --git a/src/html.rs b/src/html.rs index bc4e4bfbc..86b7b5cb1 100644 --- a/src/html.rs +++ b/src/html.rs @@ -287,6 +287,7 @@ 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}; @@ -450,6 +451,9 @@ 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; @@ -483,6 +487,8 @@ 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; @@ -520,8 +526,12 @@ 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; @@ -555,6 +565,10 @@ test some special html-characters as < > and & but also " 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; @@ -618,18 +632,22 @@ test some special html-characters as < > and & but also " and &#x #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn test_cp1252_html() -> Result<()> { - let t = TestContext::new_alice().await; + let mut tcm = TestContextManager::new(); + let alice = &tcm.alice().await; + alice + .set_config(Config::ProcessUnencrypted, Some("1")) + .await?; receive_imf( - &t, + alice, include_bytes!("../test-data/message/cp1252-html.eml"), false, ) .await?; - let msg = t.get_last_msg().await; + let msg = alice.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(&t).await?.unwrap(); + let html = msg.get_id().get_html(alice).await?.unwrap(); println!("{html}"); assert!(html.contains("foo bar ä ö ü ß")); Ok(()) diff --git a/src/imap.rs b/src/imap.rs index 892253bc2..09c89eda3 100644 --- a/src/imap.rs +++ b/src/imap.rs @@ -1996,12 +1996,21 @@ 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 = !blocked_contact || maybe_ndn; + let should_download = maybe_ndn + || (!blocked_contact + && (is_encrypted || context.get_config_bool(Config::ProcessUnencrypted).await?)); Ok(should_download) } diff --git a/src/imap/session.rs b/src/imap/session.rs index 8d4e7e087..e1e397574 100644 --- a/src/imap/session.rs +++ b/src/imap/session.rs @@ -21,6 +21,7 @@ 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\ diff --git a/src/location.rs b/src/location.rs index ac0ff2a47..dc2774dc9 100644 --- a/src/location.rs +++ b/src/location.rs @@ -939,7 +939,9 @@ mod tests { /// Tests that location.kml is hidden. #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn receive_location_kml() -> Result<()> { - let alice = TestContext::new_alice().await; + let mut tcm = TestContextManager::new(); + let alice = &tcm.alice().await; + alice.set_config(Config::ProcessUnencrypted, Some("1")).await?; receive_imf( &alice, diff --git a/src/message/message_tests.rs b/src/message/message_tests.rs index dc63f86a1..a5b223fc2 100644 --- a/src/message/message_tests.rs +++ b/src/message/message_tests.rs @@ -139,23 +139,14 @@ 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 alice = TestContext::new_alice().await; - receive_imf( - &alice, - b"From: Bob \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(); + 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; // 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()); } @@ -465,7 +456,9 @@ async fn test_get_state() -> Result<()> { #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn test_is_bot() -> Result<()> { - let alice = TestContext::new_alice().await; + let mut tcm = TestContextManager::new(); + let alice = &tcm.alice().await; + alice.set_config(Config::ProcessUnencrypted, Some("1")).await?; // Alice receives an auto-generated non-chat message. // @@ -473,7 +466,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 \n\ To: alice@example.org\n\ Message-ID: <789@example.com>\n\ @@ -492,7 +485,7 @@ async fn test_is_bot() -> Result<()> { // Alice receives a message from Bob the bot. receive_imf( - &alice, + alice, b"From: Bob \n\ To: alice@example.org\n\ Chat-Version: 1.0\n\ @@ -512,7 +505,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 \n\ To: alice@example.org\n\ Chat-Version: 1.0\n\ @@ -526,7 +519,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(()) diff --git a/src/mimeparser/mimeparser_tests.rs b/src/mimeparser/mimeparser_tests.rs index ee67f48eb..9d58e8a39 100644 --- a/src/mimeparser/mimeparser_tests.rs +++ b/src/mimeparser/mimeparser_tests.rs @@ -1503,31 +1503,23 @@ 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 alice = TestContext::new_alice().await; - let bob = TestContext::new_bob().await; + let mut tcm = TestContextManager::new(); + let alice = &tcm.alice().await; + let alice2 = &tcm.alice().await; + let bob = &tcm.bob().await; - let raw = br"Date: Thu, 28 Jan 2021 00:26:57 +0000 -Chat-Version: 1.0\n\ -Message-ID: -To: Bob -From: Alice -Subject: subject -Chat-Disposition-Notification-To: alice@example.org - -Message. -"; + let chat_id = alice.create_chat(bob).await.id; + let sent = alice.send_text(chat_id, "Message.").await; // Bob receives message. - receive_imf(&bob, raw, false).await?; - let msg = bob.get_last_msg().await; + let bob_msg = bob.recv_msg(&sent).await; // Message is incoming. - assert!(msg.param.get_bool(Param::WantsMdn).unwrap()); + assert!(bob_msg.param.get_bool(Param::WantsMdn).unwrap()); // Alice receives copy-to-self. - receive_imf(&alice, raw, false).await?; - let msg = alice.get_last_msg().await; + let alice2_msg = alice2.recv_msg(&sent).await; // Message is outgoing, don't send read receipt to self. - assert!(msg.param.get_bool(Param::WantsMdn).is_none()); + assert!(alice2_msg.param.get_bool(Param::WantsMdn).is_none()); Ok(()) } @@ -1604,7 +1596,9 @@ 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 t = TestContext::new_alice().await; + let mut tcm = TestContextManager::new(); + let t = tcm.alice().await; + t.set_config(Config::ProcessUnencrypted, Some("1")).await?; let original = include_bytes!("../../test-data/message/ms_exchange_report_original_message.eml"); @@ -2048,6 +2042,8 @@ 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(); diff --git a/src/receive_imf.rs b/src/receive_imf.rs index 35b60002e..f7a3c7dcd 100644 --- a/src/receive_imf.rs +++ b/src/receive_imf.rs @@ -505,6 +505,11 @@ 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()); diff --git a/src/receive_imf/receive_imf_tests.rs b/src/receive_imf/receive_imf_tests.rs index f36295717..b4b9abd74 100644 --- a/src/receive_imf/receive_imf_tests.rs +++ b/src/receive_imf/receive_imf_tests.rs @@ -100,6 +100,9 @@ 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(); @@ -154,6 +157,9 @@ 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\ @@ -354,6 +360,9 @@ 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(); @@ -387,6 +396,9 @@ 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(); @@ -434,6 +446,9 @@ 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(); @@ -590,6 +605,9 @@ 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, @@ -674,6 +692,7 @@ 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, @@ -715,6 +734,7 @@ 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, @@ -772,6 +792,9 @@ 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, @@ -807,6 +830,7 @@ 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?; @@ -880,6 +904,8 @@ 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(); @@ -921,6 +947,8 @@ 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?; @@ -971,6 +999,9 @@ 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; @@ -1005,6 +1036,9 @@ 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(); @@ -1035,6 +1069,9 @@ 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(); @@ -1062,6 +1099,9 @@ 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(); @@ -1084,6 +1124,8 @@ 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 \n\ @@ -1108,6 +1150,7 @@ 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( @@ -1160,6 +1203,7 @@ 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, @@ -1193,6 +1237,7 @@ 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, @@ -1218,6 +1263,7 @@ 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, @@ -1243,6 +1289,7 @@ 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, @@ -1276,6 +1323,7 @@ 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, @@ -1298,6 +1346,7 @@ 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, @@ -1318,6 +1367,9 @@ 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 @@ -1345,6 +1397,9 @@ 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, @@ -1369,6 +1424,9 @@ 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(); @@ -1407,6 +1465,9 @@ 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, @@ -1429,6 +1490,9 @@ 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( @@ -1461,6 +1525,10 @@ 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!( @@ -1490,6 +1558,9 @@ 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"), @@ -1510,6 +1581,9 @@ 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"), @@ -1535,6 +1609,9 @@ 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, @@ -1555,6 +1632,9 @@ 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". @@ -1632,6 +1712,10 @@ 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 . @@ -1698,6 +1782,11 @@ 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(); @@ -1912,6 +2001,7 @@ 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 [ @@ -1993,6 +2083,10 @@ 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( @@ -2018,6 +2112,9 @@ 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, @@ -2076,6 +2173,8 @@ 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, "", @@ -2155,6 +2254,8 @@ 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, "", @@ -2224,11 +2325,15 @@ 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 = TestContext::new_alice().await; + let t = &tcm.alice().await; + t.set_config_bool(Config::ProcessUnencrypted, true) + .await + .unwrap(); 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?= @@ -2270,7 +2375,7 @@ Message-ID: " assert_eq!(group_chat.name, "single reply-to"); receive_imf( - &t, + t, format!( r#"Subject: Re: single reply-to To: "Alice" @@ -2402,8 +2507,12 @@ 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 = TestContext::new_alice().await; + let t = &tcm.alice().await; + t.set_config_bool(Config::ProcessUnencrypted, true) + .await + .unwrap(); receive_imf( &t, @@ -2448,7 +2557,7 @@ Message-ID: " // =============== 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 @@ -2658,6 +2767,7 @@ 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, @@ -3253,6 +3363,9 @@ 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?; @@ -3289,6 +3402,7 @@ 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(); @@ -3336,6 +3450,7 @@ 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. // @@ -3407,6 +3522,9 @@ 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(); @@ -3421,6 +3539,8 @@ 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. @@ -3459,6 +3579,11 @@ 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"); @@ -3568,6 +3693,7 @@ 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, @@ -3619,6 +3745,9 @@ 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( @@ -4051,6 +4180,9 @@ 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(); @@ -4143,6 +4275,9 @@ 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(); @@ -4202,6 +4337,9 @@ 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( @@ -4365,6 +4503,10 @@ 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\ @@ -4400,12 +4542,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 = &TestContext::new().await; + let bob = &tcm.unconfigured().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 = &TestContext::new().await; + let malice = &tcm.unconfigured().await; malice.configure_addr(alice_addr).await; let malice_chat_id = tcm @@ -4647,6 +4789,7 @@ 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\ @@ -4711,6 +4854,7 @@ 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(); @@ -4840,6 +4984,7 @@ 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 @@ -5313,6 +5458,9 @@ 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, @@ -5454,6 +5602,11 @@ 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; @@ -5533,6 +5686,7 @@ 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); diff --git a/src/securejoin/securejoin_tests.rs b/src/securejoin/securejoin_tests.rs index 330d6716e..ef73bd6b4 100644 --- a/src/securejoin/securejoin_tests.rs +++ b/src/securejoin/securejoin_tests.rs @@ -772,6 +772,9 @@ 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 @@ -1415,6 +1418,9 @@ 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?; diff --git a/src/tests/verified_chats.rs b/src/tests/verified_chats.rs index 055fe7787..15e72e33a 100644 --- a/src/tests/verified_chats.rs +++ b/src/tests/verified_chats.rs @@ -332,6 +332,7 @@ 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; diff --git a/src/webxdc/webxdc_tests.rs b/src/webxdc/webxdc_tests.rs index 85c38c851..b1fa17042 100644 --- a/src/webxdc/webxdc_tests.rs +++ b/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_email_chat(&bob).await.id; + let alice_chat_id = alice.create_chat(&bob).await.id; // prepare webxdc instance, // status updates are not sent for drafts, therefore send_webxdc_status_update() returns Ok(None) @@ -1030,8 +1030,6 @@ 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?,