Emit event on Room when a user shares a new project

crates/collab/src/integration_tests.rs

@@ -5,10 +5,10 @@ use crate::{
 };
 use ::rpc::Peer;
 use anyhow::anyhow;
-use call::Room;
+use call::{room, Room};
 use client::{
     self, test::FakeHttpClient, Channel, ChannelDetails, ChannelList, Client, Connection,
-    Credentials, EstablishConnectionError, UserStore, RECEIVE_TIMEOUT,
+    Credentials, EstablishConnectionError, User, UserStore, RECEIVE_TIMEOUT,
 };
 use collections::{BTreeMap, HashMap, HashSet};
 use editor::{
@@ -40,7 +40,8 @@ use serde_json::json;
 use settings::{Formatter, Settings};
 use sqlx::types::time::OffsetDateTime;
 use std::{
-    env,
+    cell::RefCell,
+    env, mem,
     ops::Deref,
     path::{Path, PathBuf},
     rc::Rc,
@@ -556,6 +557,86 @@ async fn test_host_disconnect(
     });
 }
 
+#[gpui::test(iterations = 10)]
+async fn test_room_events(
+    deterministic: Arc<Deterministic>,
+    cx_a: &mut TestAppContext,
+    cx_b: &mut TestAppContext,
+) {
+    deterministic.forbid_parking();
+    let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
+    let client_a = server.create_client(cx_a, "user_a").await;
+    let client_b = server.create_client(cx_b, "user_b").await;
+    client_a.fs.insert_tree("/a", json!({})).await;
+    client_b.fs.insert_tree("/b", json!({})).await;
+
+    let (project_a, _) = client_a.build_local_project("/a", cx_a).await;
+    let (project_b, _) = client_b.build_local_project("/b", cx_b).await;
+
+    let (room_id, mut rooms) = server
+        .create_rooms(&mut [(&client_a, cx_a), (&client_b, cx_b)])
+        .await;
+
+    let room_a = rooms.remove(0);
+    let room_a_events = room_events(&room_a, cx_a);
+
+    let room_b = rooms.remove(0);
+    let room_b_events = room_events(&room_b, cx_b);
+
+    let project_a_id = project_a
+        .update(cx_a, |project, cx| project.share(room_id, cx))
+        .await
+        .unwrap();
+    deterministic.run_until_parked();
+    assert_eq!(mem::take(&mut *room_a_events.borrow_mut()), vec![]);
+    assert_eq!(
+        mem::take(&mut *room_b_events.borrow_mut()),
+        vec![room::Event::RemoteProjectShared {
+            owner: Arc::new(User {
+                id: client_a.user_id().unwrap(),
+                github_login: "user_a".to_string(),
+                avatar: None,
+            }),
+            project_id: project_a_id,
+        }]
+    );
+
+    let project_b_id = project_b
+        .update(cx_b, |project, cx| project.share(room_id, cx))
+        .await
+        .unwrap();
+    deterministic.run_until_parked();
+    assert_eq!(
+        mem::take(&mut *room_a_events.borrow_mut()),
+        vec![room::Event::RemoteProjectShared {
+            owner: Arc::new(User {
+                id: client_b.user_id().unwrap(),
+                github_login: "user_b".to_string(),
+                avatar: None,
+            }),
+            project_id: project_b_id,
+        }]
+    );
+    assert_eq!(mem::take(&mut *room_b_events.borrow_mut()), vec![]);
+
+    fn room_events(
+        room: &ModelHandle<Room>,
+        cx: &mut TestAppContext,
+    ) -> Rc<RefCell<Vec<room::Event>>> {
+        let events = Rc::new(RefCell::new(Vec::new()));
+        cx.update({
+            let events = events.clone();
+            |cx| {
+                cx.subscribe(room, move |_, event, _| {
+                    events.borrow_mut().push(event.clone())
+                })
+                .detach()
+            }
+        });
+        events
+    }
+}
+
 #[gpui::test(iterations = 10)]
 async fn test_propagate_saves_and_fs_changes(
     cx_a: &mut TestAppContext,