(feat): call crypto migration

src/calls/call_manager.rs

@@ -3,7 +3,11 @@ use once_cell::sync::Lazy;
 use std::sync::Arc;
 use uuid::Uuid;
 
-use crate::calls::{call_group::CallGroup, call_util, caller::Caller};
+use crate::calls::{
+    call_group::{CallGroup, CallSecretEnvelope},
+    call_util,
+    caller::Caller,
+};
 
 pub static CALL_GROUPS: Lazy<DashMap<Uuid, Arc<CallGroup>>> = Lazy::new(|| DashMap::new());
 #[allow(dead_code)]
@@ -74,7 +78,7 @@ pub async fn add_invite(
     call_id: Uuid,
     inviter_id: u64,
     invitee_id: u64,
-    secret: Option<String>,
+    secret: CallSecretEnvelope,
 ) -> bool {
     if let Some(cg) = CALL_GROUPS.get(&call_id) {
         let mut members = cg.members.write().await;
@@ -86,14 +90,89 @@ pub async fn add_invite(
                 members.push(Arc::new(Caller::new(invitee_id, call_id, false)));
             }
 
-            if let Some(secret) = secret {
-                let mut secrets = cg.secrets.write().await;
-                secrets.insert((inviter_id, invitee_id), secret.clone());
-                secrets.insert((invitee_id, inviter_id), secret);
-            }
+            let mut secrets = cg.secrets.write().await;
+            secrets.insert(invitee_id, secret);
 
             return true;
         }
     }
     false
 }
+
+pub fn should_forward_invite(inviter_id: u64, invitee_id: u64) -> bool {
+    inviter_id != invitee_id
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn envelope(label: &str) -> CallSecretEnvelope {
+        CallSecretEnvelope {
+            secret_id: format!("call:test:{label}"),
+            version_number: 1,
+            encrypted_secret: format!("encrypted:{label}").into_bytes(),
+            kem_ciphertext: format!("kem:{label}").into_bytes(),
+            wrapping_scheme: "mtp-call-secret-kem-chacha20poly1305-hkdf-sha256-v1".to_string(),
+        }
+    }
+
+    #[tokio::test]
+    async fn add_invite_stores_receiver_envelope_only_under_receiver_id() {
+        let call_id = Uuid::new_v4();
+        let sender_id = 11;
+        let receiver_id = 22;
+        let group = Arc::new(CallGroup::new(
+            call_id,
+            Arc::new(Caller::new(sender_id, call_id, true)),
+        ));
+        CALL_GROUPS.insert(call_id, group.clone());
+
+        let receiver_secret = envelope("receiver");
+
+        assert!(add_invite(call_id, sender_id, receiver_id, receiver_secret.clone(),).await);
+
+        assert_eq!(
+            group.get_secret_for_user(receiver_id).await,
+            Some(receiver_secret.clone())
+        );
+        assert_eq!(group.get_secret_for_user(sender_id).await, None);
+
+        CALL_GROUPS.remove(&call_id);
+    }
+
+    #[tokio::test]
+    async fn self_invite_stores_secret_without_duplicating_member() {
+        let call_id = Uuid::new_v4();
+        let sender_id = 33;
+        let group = Arc::new(CallGroup::new(
+            call_id,
+            Arc::new(Caller::new(sender_id, call_id, true)),
+        ));
+        CALL_GROUPS.insert(call_id, group.clone());
+
+        let secret = envelope("self");
+
+        assert!(add_invite(call_id, sender_id, sender_id, secret.clone()).await);
+
+        assert_eq!(group.get_secret_for_user(sender_id).await, Some(secret));
+        assert_eq!(
+            group
+                .members
+                .read()
+                .await
+                .iter()
+                .filter(|member| member.user_id == sender_id)
+                .count(),
+            1
+        );
+
+        CALL_GROUPS.remove(&call_id);
+    }
+
+    #[test]
+    fn self_invites_are_not_forwarded() {
+        assert!(!should_forward_invite(44, 44));
+        assert!(should_forward_invite(44, 55));
+    }
+}