fix permanently hiding of one-to-one chats after secure-join (#2791)

* test one-to-one chats on setup-contact/secure-join

only one chat is created after scanning a QR code:

- on setup-contact, one-to-ones are created on both sided

- on secure-join, the joined group chat is created;
  one-to-ones are not created intitally,
  but should become visible on receiving messages

* make sure, Alice creates the chat with Bob on setup-contact

not totally sure if that change in #2508 was on-purpose,
however, all yet released versions
did create the one-to-one chat also on the Inviter's (Alice) side,
so, let's stay with that,
i do not see many reasons to change that.

* unblock hidden (Blocked::Yes) one-to-one chats

one-to-one chats may be hidden by secure-join,
in case someone later writes a message to it
(not unlikely), the chat needs to be shown.

before, messages are just not shown,
the corresponding chat did not appear.

the 'Blocked' wording of a 'Chat' must not be mixed with the
'Blocking' of a contact. 'Chat-Blocking' is mostly a visibility thing,
that may change as messages come in.

this change should not affect _really_ blocked contacts -
they are filtered out already before
and their messages are usually not even downloaded.
also, before allow_creation is checked,
that may disallow chat creation for show_emails reasons.

all in all, it just does the same
as if the user has manualy deleted the chat before and it would be created.

* simplify test

src/securejoin.rs

@@ -499,6 +499,12 @@ pub(crate) async fn handle_securejoin_handshake(
 
             inviter_progress!(context, contact_id, 300);
 
+            // for setup-contact, make Alice's one-to-one chat with Bob visible
+            // (secure-join-information are shown in the group chat)
+            if !join_vg {
+                ChatId::create_for_contact(context, contact_id).await?;
+            }
+
             // Alice -> Bob
             send_alice_handshake_msg(
                 context,
@@ -936,6 +942,8 @@ mod tests {
     async fn test_setup_contact() -> Result<()> {
         let alice = TestContext::new_alice().await;
         let bob = TestContext::new_bob().await;
+        assert_eq!(Chatlist::try_load(&alice, 0, None, None).await?.len(), 0);
+        assert_eq!(Chatlist::try_load(&bob, 0, None, None).await?.len(), 0);
 
         // Setup JoinerProgress sinks.
         let (joiner_progress_tx, joiner_progress_rx) = async_std::channel::bounded(100);
@@ -954,6 +962,7 @@ mod tests {
 
         // Step 2: Bob scans QR-code, sends vc-request
         dc_join_securejoin(&bob.ctx, &qr).await?;
+        assert_eq!(Chatlist::try_load(&bob, 0, None, None).await?.len(), 1);
 
         let sent = bob.pop_sent_msg().await;
         assert!(!bob.ctx.has_ongoing().await);
@@ -965,6 +974,7 @@ mod tests {
 
         // Step 3: Alice receives vc-request, sends vc-auth-required
         alice.recv_msg(&sent).await;
+        assert_eq!(Chatlist::try_load(&alice, 0, None, None).await?.len(), 1);
 
         let sent = alice.pop_sent_msg().await;
         let msg = bob.parse_msg(&sent).await;
@@ -1041,6 +1051,11 @@ mod tests {
             VerifiedStatus::BidirectVerified
         );
 
+        // exactly one one-to-one chat should be visible for both now
+        // (check this before calling alice.create_chat() explicitly below)
+        assert_eq!(Chatlist::try_load(&alice, 0, None, None).await?.len(), 1);
+        assert_eq!(Chatlist::try_load(&bob, 0, None, None).await?.len(), 1);
+
         // Check Alice got the verified message in her 1:1 chat.
         {
             let chat = alice.create_chat(&bob).await;
@@ -1302,6 +1317,8 @@ mod tests {
     async fn test_secure_join() -> Result<()> {
         let alice = TestContext::new_alice().await;
         let bob = TestContext::new_bob().await;
+        assert_eq!(Chatlist::try_load(&alice, 0, None, None).await?.len(), 0);
+        assert_eq!(Chatlist::try_load(&bob, 0, None, None).await?.len(), 0);
 
         // Setup JoinerProgress sinks.
         let (joiner_progress_tx, joiner_progress_rx) = async_std::channel::bounded(100);
@@ -1323,12 +1340,9 @@ mod tests {
             .await
             .unwrap();
 
-        // Step 2: Bob scans QR-code, sends vg-request; blocks on ongoing process
-        let joiner = {
-            let qr = qr.clone();
-            let ctx = bob.ctx.clone();
-            async_std::task::spawn(async move { dc_join_securejoin(&ctx, &qr).await.unwrap() })
-        };
+        // Step 2: Bob scans QR-code, sends vg-request
+        let bob_chatid = dc_join_securejoin(&bob.ctx, &qr).await?;
+        assert_eq!(Chatlist::try_load(&bob, 0, None, None).await?.len(), 1);
 
         let sent = bob.pop_sent_msg().await;
         assert_eq!(sent.recipient(), "alice@example.com".parse().unwrap());
@@ -1444,9 +1458,9 @@ mod tests {
             "vg-member-added-received"
         );
 
-        let bob_chatid = joiner.await;
         let bob_chat = Chat::load_from_db(&bob.ctx, bob_chatid).await?;
         assert!(bob_chat.is_protected());
+        assert!(bob_chat.typ == Chattype::Group);
         assert!(!bob.ctx.has_ongoing().await);
 
         // On this "happy path", Alice and Bob get only a group-chat where all information are added to.
@@ -1454,6 +1468,14 @@ mod tests {
         // however, should not be visible in the UIs.
         assert_eq!(Chatlist::try_load(&alice, 0, None, None).await?.len(), 1);
         assert_eq!(Chatlist::try_load(&bob, 0, None, None).await?.len(), 1);
+
+        // If Bob then sends a direct message to alice, however, the one-to-one with Alice should appear.
+        let bobs_chat_with_alice = bob.create_chat(&alice).await;
+        let sent = bob.send_text(bobs_chat_with_alice.id, "Hello").await;
+        alice.recv_msg(&sent).await;
+        assert_eq!(Chatlist::try_load(&alice, 0, None, None).await?.len(), 2);
+        assert_eq!(Chatlist::try_load(&bob, 0, None, None).await?.len(), 2);
+
         Ok(())
     }
 }