diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2c8c6dcfc..45fb6b01a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,7 +3,7 @@
 ## Unreleased
 
 ### Changes
-- refactorings #3354 #3347
+- refactorings #3354 #3347 #3353
 
 ### Fixes
 - do not unnecessarily SELECT folders if there are no operations planned on
diff --git a/src/blob.rs b/src/blob.rs
index 3f20a98d0..019fdaa87 100644
--- a/src/blob.rs
+++ b/src/blob.rs
@@ -1083,8 +1083,7 @@ mod tests {
         assert_eq!(img.width() as u32, compressed_width);
         assert_eq!(img.height() as u32, compressed_height);
 
-        bob.recv_msg(&sent).await;
-        let bob_msg = bob.get_last_msg().await;
+        let bob_msg = bob.recv_msg(&sent).await;
         assert_eq!(bob_msg.get_width() as u32, compressed_width);
         assert_eq!(bob_msg.get_height() as u32, compressed_height);
         let file = bob_msg.get_file(&bob).unwrap();
diff --git a/src/chat.rs b/src/chat.rs
index 856486e41..2a9687fca 100644
--- a/src/chat.rs
+++ b/src/chat.rs
@@ -41,7 +41,7 @@ use crate::webxdc::WEBXDC_SUFFIX;
 use crate::{location, sql};
 
 /// An chat item, such as a message or a marker.
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, PartialEq)]
 pub enum ChatItem {
     Message {
         msg_id: MsgId,
@@ -3676,12 +3676,11 @@ mod tests {
 
         // create group and sync it to the second device
         let a1_chat_id = create_group_chat(&a1, ProtectionStatus::Unprotected, "foo").await?;
-        send_text_msg(&a1, a1_chat_id, "ho!".to_string()).await?;
+        a1.send_text(a1_chat_id, "ho!").await;
         let a1_msg = a1.get_last_msg().await;
         let a1_chat = Chat::load_from_db(&a1, a1_chat_id).await?;
 
-        a2.recv_msg(&a1.pop_sent_msg().await).await;
-        let a2_msg = a2.get_last_msg().await;
+        let a2_msg = a2.recv_msg(&a1.pop_sent_msg().await).await;
         let a2_chat_id = a2_msg.chat_id;
         let a2_chat = Chat::load_from_db(&a2, a2_chat_id).await?;
 
@@ -3700,8 +3699,7 @@ mod tests {
         add_contact_to_chat(&a1, a1_chat_id, bob).await?;
         let a1_msg = a1.get_last_msg().await;
 
-        a2.recv_msg(&a1.pop_sent_msg().await).await;
-        let a2_msg = a2.get_last_msg().await;
+        let a2_msg = a2.recv_msg(&a1.pop_sent_msg().await).await;
 
         assert!(a1_msg.is_system_message());
         assert!(a2_msg.is_system_message());
@@ -3714,8 +3712,7 @@ mod tests {
         set_chat_name(&a1, a1_chat_id, "bar").await?;
         let a1_msg = a1.get_last_msg().await;
 
-        a2.recv_msg(&a1.pop_sent_msg().await).await;
-        let a2_msg = a2.get_last_msg().await;
+        let a2_msg = a2.recv_msg(&a1.pop_sent_msg().await).await;
 
         assert!(a1_msg.is_system_message());
         assert!(a2_msg.is_system_message());
@@ -3728,8 +3725,7 @@ mod tests {
         remove_contact_from_chat(&a1, a1_chat_id, bob).await?;
         let a1_msg = a1.get_last_msg().await;
 
-        a2.recv_msg(&a1.pop_sent_msg().await).await;
-        let a2_msg = a2.get_last_msg().await;
+        let a2_msg = a2.recv_msg(&a1.pop_sent_msg().await).await;
 
         assert!(a1_msg.is_system_message());
         assert!(a2_msg.is_system_message());
@@ -3792,10 +3788,9 @@ mod tests {
         bob.recv_msg(&add3).await;
         async_std::task::sleep(std::time::Duration::from_millis(1100)).await;
 
-        bob.recv_msg(&add2).await;
+        let bob_chat_id = bob.recv_msg(&add2).await.chat_id;
         async_std::task::sleep(std::time::Duration::from_millis(1100)).await;
 
-        let bob_chat_id = bob.get_last_msg().await.chat_id;
         assert_eq!(get_chat_contacts(&bob, bob_chat_id).await?.len(), 4);
 
         bob.recv_msg(&remove2).await;
@@ -3864,12 +3859,11 @@ mod tests {
 
         // Alice sends first message to group.
         let sent_msg = alice.send_text(alice_chat_id, "Hello!").await;
-        bob.recv_msg(&sent_msg).await;
+        let bob_msg = bob.recv_msg(&sent_msg).await;
 
         assert_eq!(get_chat_contacts(&alice, alice_chat_id).await?.len(), 2);
 
         // Bob leaves the group.
-        let bob_msg = bob.get_last_msg().await;
         let bob_chat_id = bob_msg.chat_id;
         bob_chat_id.accept(&bob).await?;
         remove_contact_from_chat(&bob, bob_chat_id, ContactId::SELF).await?;
@@ -4937,8 +4931,7 @@ mod tests {
         let mime = sent_msg.payload();
         assert_eq!(mime.match_indices("Chat-Content: sticker").count(), 1);
 
-        bob.recv_msg(&sent_msg).await;
-        let msg = bob.get_last_msg().await;
+        let msg = bob.recv_msg(&sent_msg).await;
         assert_eq!(msg.chat_id, bob_chat.id);
         assert_eq!(msg.get_viewtype(), Viewtype::Sticker);
         assert_eq!(msg.get_filename(), Some(filename.to_string()));
@@ -5000,18 +4993,16 @@ mod tests {
 
         // send sticker to bob
         let sent_msg = alice.send_msg(alice_chat.get_id(), &mut msg).await;
-        bob.recv_msg(&sent_msg).await;
-        let msg = bob.get_last_msg().await;
+        let msg = bob.recv_msg(&sent_msg).await;
 
         // forward said sticker to alice
         forward_msgs(&bob, &[msg.id], bob_chat.get_id()).await?;
         let forwarded_msg = bob.pop_sent_msg().await;
-        alice.recv_msg(&forwarded_msg).await;
-
-        // retrieve forwarded sticker which should not have forwarded-flag
-        let msg = alice.get_last_msg().await;
 
+        let msg = alice.recv_msg(&forwarded_msg).await;
+        // forwarded sticker should not have forwarded-flag
         assert!(!msg.is_forwarded());
+
         Ok(())
     }
 
@@ -5025,15 +5016,12 @@ mod tests {
         let mut msg = Message::new(Viewtype::Text);
         msg.set_text(Some("Hi Bob".to_owned()));
         let sent_msg = alice.send_msg(alice_chat.get_id(), &mut msg).await;
-        bob.recv_msg(&sent_msg).await;
-        let msg = bob.get_last_msg().await;
+        let msg = bob.recv_msg(&sent_msg).await;
 
         forward_msgs(&bob, &[msg.id], bob_chat.get_id()).await?;
 
         let forwarded_msg = bob.pop_sent_msg().await;
-        alice.recv_msg(&forwarded_msg).await;
-
-        let msg = alice.get_last_msg().await;
+        let msg = alice.recv_msg(&forwarded_msg).await;
         assert!(msg.get_text().unwrap() == "Hi Bob");
         assert!(msg.is_forwarded());
         Ok(())
@@ -5048,23 +5036,19 @@ mod tests {
 
         // Alice sends a message to Bob.
         let sent_msg = alice.send_text(alice_chat.id, "Hi Bob").await;
-        bob.recv_msg(&sent_msg).await;
-        let received_msg = bob.get_last_msg().await;
+        let received_msg = bob.recv_msg(&sent_msg).await;
 
         // Bob quotes received message and sends a reply to Alice.
         let mut reply = Message::new(Viewtype::Text);
         reply.set_text(Some("Reply".to_owned()));
         reply.set_quote(&bob, Some(&received_msg)).await?;
         let sent_reply = bob.send_msg(bob_chat.id, &mut reply).await;
-        alice.recv_msg(&sent_reply).await;
-        let received_reply = alice.get_last_msg().await;
+        let received_reply = alice.recv_msg(&sent_reply).await;
 
         // Alice forwards a reply.
         forward_msgs(&alice, &[received_reply.id], alice_chat.get_id()).await?;
         let forwarded_msg = alice.pop_sent_msg().await;
-        bob.recv_msg(&forwarded_msg).await;
-
-        let alice_forwarded_msg = alice.get_last_msg().await;
+        let alice_forwarded_msg = bob.recv_msg(&forwarded_msg).await;
         assert!(alice_forwarded_msg.quoted_message(&alice).await?.is_none());
         assert_eq!(
             alice_forwarded_msg.quoted_text(),
@@ -5096,8 +5080,7 @@ mod tests {
         let sent_group_msg = alice
             .send_text(alice_group_chat_id, "Hi Bob and Claire")
             .await;
-        bob.recv_msg(&sent_group_msg).await;
-        let bob_group_chat_id = bob.get_last_msg().await.chat_id;
+        let bob_group_chat_id = bob.recv_msg(&sent_group_msg).await.chat_id;
 
         // Alice deletes a message on her device.
         // This is needed to make assignment of further messages received in this group
@@ -5107,15 +5090,13 @@ mod tests {
 
         // Alice sends a message to Bob.
         let sent_msg = alice.send_text(alice_chat.id, "Hi Bob").await;
-        bob.recv_msg(&sent_msg).await;
-        let received_msg = bob.get_last_msg().await;
+        let received_msg = bob.recv_msg(&sent_msg).await;
         assert_eq!(received_msg.get_text(), Some("Hi Bob".to_string()));
         assert_eq!(received_msg.chat_id, bob_chat.id);
 
         // Alice sends another message to Bob, this has first message as a parent.
         let sent_msg = alice.send_text(alice_chat.id, "Hello Bob").await;
-        bob.recv_msg(&sent_msg).await;
-        let received_msg = bob.get_last_msg().await;
+        let received_msg = bob.recv_msg(&sent_msg).await;
         assert_eq!(received_msg.get_text(), Some("Hello Bob".to_string()));
         assert_eq!(received_msg.chat_id, bob_chat.id);
 
@@ -5152,8 +5133,7 @@ mod tests {
         // Bob forwards that message to Claire -
         // Claire should not get information about Alice for the original Group
         let bob = TestContext::new_bob().await;
-        bob.recv_msg(&sent_msg).await;
-        let orig_msg = bob.get_last_msg().await;
+        let orig_msg = bob.recv_msg(&sent_msg).await;
         let claire_id = Contact::create(&bob, "claire", "claire@foo").await?;
         let single_id = ChatId::create_for_contact(&bob, claire_id).await?;
         let group_id = create_group_chat(&bob, ProtectionStatus::Unprotected, "group2").await?;
@@ -5200,15 +5180,16 @@ mod tests {
 
         // Bob receives all messages
         let bob = TestContext::new_bob().await;
-        bob.recv_msg(&sent1).await;
-        let msg = bob.get_last_msg().await;
+        let msg = bob.recv_msg(&sent1).await;
         assert_eq!(msg.get_text().unwrap(), "alice->bob");
         assert_eq!(get_chat_contacts(&bob, msg.chat_id).await?.len(), 2);
         assert_eq!(get_chat_msgs(&bob, msg.chat_id, 0).await?.len(), 1);
         bob.recv_msg(&sent2).await;
         assert_eq!(get_chat_contacts(&bob, msg.chat_id).await?.len(), 3);
         assert_eq!(get_chat_msgs(&bob, msg.chat_id, 0).await?.len(), 2);
-        bob.recv_msg(&sent3).await;
+        let received = bob.recv_msg_opt(&sent3).await;
+        // No message should actually be added since we already know this message:
+        assert!(received.is_none());
         assert_eq!(get_chat_contacts(&bob, msg.chat_id).await?.len(), 3);
         assert_eq!(get_chat_msgs(&bob, msg.chat_id, 0).await?.len(), 2);
 
@@ -5216,8 +5197,7 @@ mod tests {
         let claire = TestContext::new().await;
         claire.configure_addr("claire@example.org").await;
         claire.recv_msg(&sent2).await;
-        claire.recv_msg(&sent3).await;
-        let msg = claire.get_last_msg().await;
+        let msg = claire.recv_msg(&sent3).await;
         assert_eq!(msg.get_text().unwrap(), "alice->bob");
         assert_eq!(get_chat_contacts(&claire, msg.chat_id).await?.len(), 3);
         assert_eq!(get_chat_msgs(&claire, msg.chat_id, 0).await?.len(), 2);
@@ -5240,8 +5220,7 @@ mod tests {
         let sent1 = alice.send_text(alice_grp, "alice->bob").await;
 
         let bob = TestContext::new_bob().await;
-        bob.recv_msg(&sent1).await;
-        let msg = bob.get_last_msg().await;
+        let msg = bob.recv_msg(&sent1).await;
         assert!(resend_msgs(&bob, &[msg.id]).await.is_err());
 
         Ok(())
@@ -5262,8 +5241,7 @@ mod tests {
 
         // Bob now can send an encrypted message
         let bob = TestContext::new_bob().await;
-        bob.recv_msg(&sent1).await;
-        let msg = bob.get_last_msg().await;
+        let msg = bob.recv_msg(&sent1).await;
         assert!(!msg.get_showpadlock());
 
         msg.chat_id.accept(&bob).await?;
@@ -5347,8 +5325,7 @@ mod tests {
 
         let chat_bob = bob.create_chat(&alice).await;
         send_text_msg(&bob, chat_bob.id, "ho!".to_string()).await?;
-        alice.recv_msg(&bob.pop_sent_msg().await).await;
-        let msg = alice.get_last_msg().await;
+        let msg = alice.recv_msg(&bob.pop_sent_msg().await).await;
         assert!(msg.get_showpadlock());
 
         // test broadcast list
@@ -5368,8 +5345,7 @@ mod tests {
         let msg = alice.get_last_msg().await;
         assert_eq!(msg.chat_id, chat.id);
 
-        bob.recv_msg(&alice.pop_sent_msg().await).await;
-        let msg = bob.get_last_msg().await;
+        let msg = bob.recv_msg(&alice.pop_sent_msg().await).await;
         assert_eq!(msg.get_text(), Some("ola!".to_string()));
         assert!(!msg.get_showpadlock()); // avoid leaking recipients in encryption data
         let chat = Chat::load_from_db(&bob, msg.chat_id).await?;
diff --git a/src/dc_receive_imf.rs b/src/dc_receive_imf.rs
index b55f55923..22eac3182 100644
--- a/src/dc_receive_imf.rs
+++ b/src/dc_receive_imf.rs
@@ -47,16 +47,9 @@ pub struct ReceivedMsg {
     pub chat_id: ChatId,
     pub state: MessageState,
     pub sort_timestamp: i64,
-    // Feel free to add more fields here
-}
-
-/// Information about added message parts.
-struct AddedParts {
-    /// Common info about received messages.
-    pub received_msg: ReceivedMsg,
 
     /// IDs of inserted rows in messages table.
-    pub created_db_entries: Vec<MsgId>,
+    pub msg_ids: Vec<MsgId>,
 
     /// Whether IMAP messages should be immediately deleted.
     pub needs_delete_job: bool,
@@ -186,7 +179,7 @@ pub(crate) async fn dc_receive_imf_inner(
         .map_or(rcvd_timestamp, |value| min(value, rcvd_timestamp));
 
     // Add parts
-    let added_parts = add_parts(
+    let received_msg = add_parts(
         context,
         &mut mime_parser,
         imf_raw,
@@ -211,7 +204,7 @@ pub(crate) async fn dc_receive_imf_inner(
     // Update gossiped timestamp for the chat if someone else or our other device sent
     // Autocrypt-Gossip for all recipients in the chat to avoid sending Autocrypt-Gossip ourselves
     // and waste traffic.
-    let chat_id = added_parts.received_msg.chat_id;
+    let chat_id = received_msg.chat_id;
     if !chat_id.is_special()
         && mime_parser
             .recipients
@@ -229,7 +222,7 @@ pub(crate) async fn dc_receive_imf_inner(
         }
     }
 
-    let insert_msg_id = if let Some(msg_id) = added_parts.created_db_entries.last() {
+    let insert_msg_id = if let Some(msg_id) = received_msg.msg_ids.last() {
         *msg_id
     } else {
         MsgId::new_unset()
@@ -310,8 +303,8 @@ pub(crate) async fn dc_receive_imf_inner(
     // Get user-configured server deletion
     let delete_server_after = context.get_config_delete_server_after().await?;
 
-    if !added_parts.created_db_entries.is_empty() {
-        if added_parts.needs_delete_job
+    if !received_msg.msg_ids.is_empty() {
+        if received_msg.needs_delete_job
             || (delete_server_after == Some(0) && is_partial_download.is_none())
         {
             context
@@ -330,12 +323,12 @@ pub(crate) async fn dc_receive_imf_inner(
     if replace_partial_download {
         context.emit_msgs_changed(chat_id, MsgId::new(0));
     } else if !chat_id.is_trash() {
-        let fresh = added_parts.received_msg.state == MessageState::InFresh;
-        for msg_id in added_parts.created_db_entries {
+        let fresh = received_msg.state == MessageState::InFresh;
+        for msg_id in &received_msg.msg_ids {
             if incoming && fresh {
-                context.emit_incoming_msg(chat_id, msg_id);
+                context.emit_incoming_msg(chat_id, *msg_id);
             } else {
-                context.emit_msgs_changed(chat_id, msg_id);
+                context.emit_msgs_changed(chat_id, *msg_id);
             };
         }
     }
@@ -344,7 +337,7 @@ pub(crate) async fn dc_receive_imf_inner(
         .handle_reports(context, from_id, sent_timestamp, &mime_parser.parts)
         .await;
 
-    Ok(Some(added_parts.received_msg))
+    Ok(Some(received_msg))
 }
 
 /// Converts "From" field to contact id.
@@ -408,7 +401,7 @@ async fn add_parts(
     is_partial_download: Option<u32>,
     fetching_existing_messages: bool,
     prevent_rename: bool,
-) -> Result<AddedParts> {
+) -> Result<ReceivedMsg> {
     let mut chat_id = None;
     let mut chat_id_blocked = Blocked::Not;
 
@@ -1181,15 +1174,11 @@ INSERT INTO msgs
         }
     }
 
-    let received_msg = ReceivedMsg {
+    Ok(ReceivedMsg {
         chat_id,
         state,
         sort_timestamp,
-    };
-
-    Ok(AddedParts {
-        received_msg,
-        created_db_entries,
+        msg_ids: created_db_entries,
         needs_delete_job,
     })
 }
@@ -3749,8 +3738,7 @@ YEAAAAAA!.
         let chat_alice = alice.create_chat(&bob).await;
         chat::send_text_msg(&alice, chat_alice.id, "hi!".to_string()).await?;
 
-        bob.recv_msg(&alice.pop_sent_msg().await).await;
-        let msg = bob.get_last_msg().await;
+        let msg = bob.recv_msg(&alice.pop_sent_msg().await).await;
         assert_eq!(msg.get_text(), Some("hi!".to_string()));
         assert!(!msg.get_showpadlock());
         let mime = message::get_mime_headers(&bob, msg.id).await?;
@@ -3769,25 +3757,23 @@ YEAAAAAA!.
         let chat_alice = alice.create_chat(&bob).await;
         chat::send_text_msg(&alice, chat_alice.id, "hi!".to_string()).await?;
 
-        bob.recv_msg(&alice.pop_sent_msg().await).await;
-        let msg = bob.get_last_msg().await;
+        let msg = bob.recv_msg(&alice.pop_sent_msg().await).await;
         assert_eq!(msg.get_text(), Some("hi!".to_string()));
         assert!(!msg.get_showpadlock());
         let mime = message::get_mime_headers(&bob, msg.id).await?;
         let mime_str = String::from_utf8_lossy(&mime);
-        assert!(mime_str.contains("Received:"));
+        assert!(mime_str.contains("Message-ID:"));
         assert!(mime_str.contains("From:"));
 
         // another one, from bob to alice, that gets encrypted
         let chat_bob = bob.create_chat(&alice).await;
         chat::send_text_msg(&bob, chat_bob.id, "ho!".to_string()).await?;
-        alice.recv_msg(&bob.pop_sent_msg().await).await;
-        let msg = alice.get_last_msg().await;
+        let msg = alice.recv_msg(&bob.pop_sent_msg().await).await;
         assert_eq!(msg.get_text(), Some("ho!".to_string()));
         assert!(msg.get_showpadlock());
         let mime = message::get_mime_headers(&alice, msg.id).await?;
         let mime_str = String::from_utf8_lossy(&mime);
-        assert!(mime_str.contains("Received:"));
+        assert!(mime_str.contains("Message-ID:"));
         assert!(mime_str.contains("From:"));
         Ok(())
     }
@@ -4472,16 +4458,14 @@ Second thread."#;
         let alice_first_reply = alice
             .send_text(alice_first_msg.chat_id, "First reply")
             .await;
-        bob.recv_msg(&alice_first_reply).await;
-        let bob_first_reply = bob.get_last_msg().await;
+        let bob_first_reply = bob.recv_msg(&alice_first_reply).await;
         assert_eq!(bob_first_reply.chat_id, bob_first_msg.chat_id);
 
         alice_second_msg.chat_id.accept(&alice).await?;
         let alice_second_reply = alice
             .send_text(alice_second_msg.chat_id, "Second reply")
             .await;
-        bob.recv_msg(&alice_second_reply).await;
-        let bob_second_reply = bob.get_last_msg().await;
+        let bob_second_reply = bob.recv_msg(&alice_second_reply).await;
         assert_eq!(bob_second_reply.chat_id, bob_second_msg.chat_id);
 
         // Alice adds Fiona to both ad hoc groups.
@@ -4496,13 +4480,11 @@ Second thread."#;
 
         chat::add_contact_to_chat(&alice, alice_first_msg.chat_id, alice_fiona_contact_id).await?;
         let alice_first_invite = alice.pop_sent_msg().await;
-        fiona.recv_msg(&alice_first_invite).await;
-        let fiona_first_invite = fiona.get_last_msg().await;
+        let fiona_first_invite = fiona.recv_msg(&alice_first_invite).await;
 
         chat::add_contact_to_chat(&alice, alice_second_msg.chat_id, alice_fiona_contact_id).await?;
         let alice_second_invite = alice.pop_sent_msg().await;
-        fiona.recv_msg(&alice_second_invite).await;
-        let fiona_second_invite = fiona.get_last_msg().await;
+        let fiona_second_invite = fiona.recv_msg(&alice_second_invite).await;
 
         // Fiona was added to two separate chats and should see two separate chats, even though they
         // don't have different group IDs to distinguish them.
@@ -4784,8 +4766,7 @@ Reply from different address
             let sent = alice.send_msg(alice_chat.id, &mut msg_alice).await;
             println!("{}", sent.payload());
 
-            bob.recv_msg(&sent).await;
-            let msg_bob = bob.get_last_msg().await;
+            let msg_bob = bob.recv_msg(&sent).await;
 
             async fn check_message(msg: &Message, t: &TestContext, content: &str) {
                 assert_eq!(msg.get_viewtype(), Viewtype::File);
@@ -4825,9 +4806,7 @@ Reply from different address
 
         alice1.recv_msg(&sent).await;
         alice2.recv_msg(&sent).await;
-        bob2.recv_msg(&sent).await;
-
-        let alice1_msg = alice1.get_last_msg().await;
+        let alice1_msg = bob2.recv_msg(&sent).await;
         assert_eq!(alice1_msg.text.unwrap(), "Hello!");
         let alice1_chat = chat::Chat::load_from_db(&alice1, alice1_msg.chat_id).await?;
         assert!(alice1_chat.is_contact_request());
diff --git a/src/html.rs b/src/html.rs
index b5ccca284..d156780ed 100644
--- a/src/html.rs
+++ b/src/html.rs
@@ -467,8 +467,8 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
         // bob: check that bob also got the html-part of the forwarded message
         let bob = TestContext::new_bob().await;
         let chat = bob.create_chat_with_contact("", "alice@example.org").await;
-        bob.recv_msg(&alice.pop_sent_msg().await).await;
-        let msg = bob.get_last_msg_in(chat.get_id()).await;
+        let msg = bob.recv_msg(&alice.pop_sent_msg().await).await;
+        assert_eq!(chat.id, msg.chat_id);
         assert_ne!(msg.get_from_id(), ContactId::SELF);
         assert_eq!(msg.is_dc_message, MessengerMessage::Yes);
         assert!(msg.is_forwarded());
@@ -503,9 +503,8 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
         // receive the message on another device
         let alice = TestContext::new_alice().await;
         assert_eq!(alice.get_config_int(Config::ShowEmails).await.unwrap(), 0); // set to "1" above, make sure it is another db
-        alice.recv_msg(&msg).await;
-        let chat = alice.get_self_chat().await;
-        let msg = alice.get_last_msg_in(chat.get_id()).await;
+        let msg = alice.recv_msg(&msg).await;
+        assert_eq!(msg.chat_id, alice.get_self_chat().await.id);
         assert_eq!(msg.get_from_id(), ContactId::SELF);
         assert_eq!(msg.is_dc_message, MessengerMessage::Yes);
         assert!(msg.get_showpadlock());
@@ -539,8 +538,8 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
 
         // let bob receive the message
         let chat_id = bob.create_chat(&alice).await.id;
-        bob.recv_msg(&alice.pop_sent_msg().await).await;
-        let msg = bob.get_last_msg_in(chat_id).await;
+        let msg = bob.recv_msg(&alice.pop_sent_msg().await).await;
+        assert_eq!(msg.chat_id, chat_id);
         assert_eq!(msg.get_text(), Some("plain text".to_string()));
         assert!(!msg.is_forwarded());
         assert!(msg.mime_modified);
diff --git a/src/message.rs b/src/message.rs
index a5f944375..9e7dbcdb6 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -2090,8 +2090,8 @@ mod tests {
             .first()
             .unwrap();
         let contact = Contact::load_from_db(&bob, contact_id).await.unwrap();
-        bob.recv_msg(&alice.pop_sent_msg().await).await;
-        let msg = bob.get_last_msg_in(chat.id).await;
+        let msg = bob.recv_msg(&alice.pop_sent_msg().await).await;
+        assert_eq!(msg.chat_id, chat.id);
         assert_eq!(msg.text, Some("bla blubb".to_string()));
         assert_eq!(
             msg.get_override_sender_name(),
@@ -2116,13 +2116,11 @@ mod tests {
 
         // alice sends to bob,
         assert_eq!(Chatlist::try_load(&bob, 0, None, None).await?.len(), 0);
-        bob.recv_msg(&alice.send_msg(alice_chat.id, &mut msg).await)
-            .await;
-        let msg1 = bob.get_last_msg().await;
+        let sent1 = alice.send_msg(alice_chat.id, &mut msg).await;
+        let msg1 = bob.recv_msg(&sent1).await;
         let bob_chat_id = msg1.chat_id;
-        bob.recv_msg(&alice.send_msg(alice_chat.id, &mut msg).await)
-            .await;
-        let msg2 = bob.get_last_msg().await;
+        let sent2 = alice.send_msg(alice_chat.id, &mut msg).await;
+        let msg2 = bob.recv_msg(&sent2).await;
         assert_eq!(msg1.chat_id, msg2.chat_id);
         let chats = Chatlist::try_load(&bob, 0, None, None).await?;
         assert_eq!(chats.len(), 1);
@@ -2143,14 +2141,12 @@ mod tests {
 
         // bob sends to alice,
         // alice knows bob and messages appear in normal chat
-        alice
+        let msg1 = alice
             .recv_msg(&bob.send_msg(bob_chat_id, &mut msg).await)
             .await;
-        let msg1 = alice.get_last_msg().await;
-        alice
+        let msg2 = alice
             .recv_msg(&bob.send_msg(bob_chat_id, &mut msg).await)
             .await;
-        let msg2 = alice.get_last_msg().await;
         let chats = Chatlist::try_load(&alice, 0, None, None).await?;
         assert_eq!(chats.len(), 1);
         assert_eq!(chats.get_chat_id(0)?, alice_chat.id);
@@ -2226,8 +2222,7 @@ mod tests {
         assert_state(&alice, alice_msg.id, MessageState::OutFailed).await;
 
         // check incoming message states on receiver side
-        bob.recv_msg(&payload).await;
-        let bob_msg = bob.get_last_msg().await;
+        let bob_msg = bob.recv_msg(&payload).await;
         assert_eq!(bob_chat.id, bob_msg.chat_id);
         assert_state(&bob, bob_msg.id, MessageState::InFresh).await;
 
diff --git a/src/test_utils.rs b/src/test_utils.rs
index dfa3a277c..8cfc937fb 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -1,7 +1,7 @@
 //! Utilities to help writing tests.
 //!
 //! This private module is only compiled for test runs.
-
+#![allow(clippy::indexing_slicing)]
 use std::collections::BTreeMap;
 use std::ops::Deref;
 use std::panic;
@@ -370,17 +370,41 @@ impl TestContext {
             .unwrap()
     }
 
-    /// Receive a message.
-    ///
-    /// Receives a message using the `dc_receive_imf()` pipeline.
-    pub async fn recv_msg(&self, msg: &SentMessage) {
-        let received_msg =
-            "Received: (Postfix, from userid 1000); Mon, 4 Dec 2006 14:51:39 +0100 (CET)\n"
-                .to_owned()
-                + msg.payload();
-        dc_receive_imf(&self.ctx, received_msg.as_bytes(), false)
+    /// Receive a message using the `dc_receive_imf()` pipeline. Panics if it's not shown
+    /// in the chat as exactly one message.
+    pub async fn recv_msg(&self, msg: &SentMessage) -> Message {
+        let received = self.recv_msg_opt(msg).await.unwrap();
+
+        assert_eq!(
+            received.msg_ids.len(),
+            1,
+            "recv_msg() can currently only receive messages with exactly one part"
+        );
+        let msg = Message::load_from_db(self, received.msg_ids[0])
             .await
             .unwrap();
+
+        let chat_msgs = chat::get_chat_msgs(self, received.chat_id, 0)
+            .await
+            .unwrap();
+        assert!(
+            chat_msgs.contains(&ChatItem::Message { msg_id: msg.id }),
+            "received message is not shown in chat, maybe it's hidden (you may have \
+                to call set_config(Config::ShowEmails, Some(\"2\")).await)"
+        );
+
+        msg
+    }
+
+    /// Receive a message using the `dc_receive_imf()` pipeline. This is similar
+    /// to `recv_msg()`, but doesn't assume that the message is shown in the chat.
+    pub async fn recv_msg_opt(
+        &self,
+        msg: &SentMessage,
+    ) -> Option<crate::dc_receive_imf::ReceivedMsg> {
+        dc_receive_imf(self, msg.payload().as_bytes(), false)
+            .await
+            .unwrap()
     }
 
     /// Gets the most recent message of a chat.
diff --git a/src/webxdc.rs b/src/webxdc.rs
index 03af87dbb..fb95a2dd4 100644
--- a/src/webxdc.rs
+++ b/src/webxdc.rs
@@ -1121,8 +1121,7 @@ mod tests {
         );
 
         // Bob receives all messages
-        bob.recv_msg(sent1).await;
-        let bob_instance = bob.get_last_msg().await;
+        let bob_instance = bob.recv_msg(sent1).await;
         let bob_chat_id = bob_instance.chat_id;
         assert_eq!(bob_instance.rfc724_mid, alice_instance.rfc724_mid);
         assert_eq!(bob_instance.viewtype, Viewtype::Webxdc);
@@ -1219,8 +1218,7 @@ mod tests {
         assert_eq!(alice_instance.chat_id, alice_chat_id);
 
         // bob receives the instance together with the initial updates in a single message
-        bob.recv_msg(&sent1).await;
-        let bob_instance = bob.get_last_msg().await;
+        let bob_instance = bob.recv_msg(&sent1).await;
         assert_eq!(bob_instance.viewtype, Viewtype::Webxdc);
         assert_eq!(bob_instance.get_filename(), Some("minimal.xdc".to_string()));
         assert!(sent1.payload().contains("Content-Type: application/json"));
@@ -1537,8 +1535,7 @@ sth_for_the = "future""#
         assert_eq!(info.summary, "sum: 2".to_string());
 
         // Bob receives the updates
-        bob.recv_msg(sent_instance).await;
-        let bob_instance = bob.get_last_msg().await;
+        let bob_instance = bob.recv_msg(sent_instance).await;
         bob.recv_msg(sent_update1).await;
         bob.recv_msg(sent_update2).await;
         let info = Message::load_from_db(&bob, bob_instance.id)
@@ -1549,8 +1546,7 @@ sth_for_the = "future""#
 
         // Alice has a second device and also receives the updates there
         let alice2 = TestContext::new_alice().await;
-        alice2.recv_msg(sent_instance).await;
-        let alice2_instance = alice2.get_last_msg().await;
+        let alice2_instance = alice2.recv_msg(sent_instance).await;
         alice2.recv_msg(sent_update1).await;
         alice2.recv_msg(sent_update2).await;
         let info = Message::load_from_db(&alice2, alice2_instance.id)
@@ -1591,8 +1587,7 @@ sth_for_the = "future""#
         assert_eq!(info.summary, "".to_string());
 
         // Bob receives the updates
-        bob.recv_msg(sent_instance).await;
-        let bob_instance = bob.get_last_msg().await;
+        let bob_instance = bob.recv_msg(sent_instance).await;
         bob.recv_msg(sent_update1).await;
         let info = Message::load_from_db(&bob, bob_instance.id)
             .await?
@@ -1643,8 +1638,7 @@ sth_for_the = "future""#
         );
 
         // Bob receives all messages
-        bob.recv_msg(sent1).await;
-        let bob_instance = bob.get_last_msg().await;
+        let bob_instance = bob.recv_msg(sent1).await;
         let bob_chat_id = bob_instance.chat_id;
         bob.recv_msg(sent2).await;
         assert_eq!(bob_chat_id.get_msg_cnt(&bob).await?, 2);
@@ -1664,8 +1658,7 @@ sth_for_the = "future""#
 
         // Alice has a second device and also receives the info message there
         let alice2 = TestContext::new_alice().await;
-        alice2.recv_msg(sent1).await;
-        let alice2_instance = alice2.get_last_msg().await;
+        let alice2_instance = alice2.recv_msg(sent1).await;
         let alice2_chat_id = alice2_instance.chat_id;
         alice2.recv_msg(sent2).await;
         assert_eq!(alice2_chat_id.get_msg_cnt(&alice2).await?, 2);
@@ -1721,8 +1714,7 @@ sth_for_the = "future""#
         assert!(update_msg.get_showpadlock());
 
         // Bob receives instance+update
-        bob.recv_msg(sent1).await;
-        let bob_instance = bob.get_last_msg().await;
+        let bob_instance = bob.recv_msg(sent1).await;
         bob.recv_msg(sent2).await;
         assert!(bob_instance.get_showpadlock());
 
@@ -1786,14 +1778,12 @@ sth_for_the = "future""#
 
         // Bob receives that instance
         let sent1 = alice.pop_sent_msg().await;
-        bob.recv_msg(&sent1).await;
-        let bob_instance = bob.get_last_msg().await;
+        let bob_instance = bob.recv_msg(&sent1).await;
         assert_eq!(bob_instance.get_text(), Some("user added text".to_string()));
 
         // Alice's second device receives the instance as well
         let alice2 = TestContext::new_alice().await;
-        alice2.recv_msg(&sent1).await;
-        let alice2_instance = alice2.get_last_msg().await;
+        let alice2_instance = alice2.recv_msg(&sent1).await;
         assert_eq!(
             alice2_instance.get_text(),
             Some("user added text".to_string())