1use crate::{
   2    rpc::{CLEANUP_TIMEOUT, RECONNECT_TIMEOUT},
   3    tests::{channel_id, room_participants, RoomParticipants, TestClient, TestServer},
   4};
   5use call::{room, ActiveCall, ParticipantLocation, Room};
   6use client::{User, RECEIVE_TIMEOUT};
   7use collections::{HashMap, HashSet};
   8use fs::{repository::GitFileStatus, FakeFs, Fs as _, RemoveOptions};
   9use futures::StreamExt as _;
  10use gpui::{
  11    px, size, AppContext, BackgroundExecutor, Model, Modifiers, MouseButton, MouseDownEvent,
  12    TestAppContext,
  13};
  14use language::{
  15    language_settings::{AllLanguageSettings, Formatter},
  16    tree_sitter_rust, Diagnostic, DiagnosticEntry, FakeLspAdapter, Language, LanguageConfig,
  17    LineEnding, OffsetRangeExt, Point, Rope,
  18};
  19use live_kit_client::MacOSDisplay;
  20use lsp::LanguageServerId;
  21use project::{
  22    search::SearchQuery, DiagnosticSummary, FormatTrigger, HoverBlockKind, Project, ProjectPath,
  23};
  24use rand::prelude::*;
  25use rpc::proto::ChannelRole;
  26use serde_json::json;
  27use settings::SettingsStore;
  28use std::{
  29    cell::{Cell, RefCell},
  30    env, future, mem,
  31    path::{Path, PathBuf},
  32    rc::Rc,
  33    sync::{
  34        atomic::{AtomicBool, Ordering::SeqCst},
  35        Arc,
  36    },
  37    time::Duration,
  38};
  39use unindent::Unindent as _;
  40
  41#[ctor::ctor]
  42fn init_logger() {
  43    if std::env::var("RUST_LOG").is_ok() {
  44        env_logger::init();
  45    }
  46}
  47
  48#[gpui::test(iterations = 10)]
  49async fn test_basic_calls(
  50    executor: BackgroundExecutor,
  51    cx_a: &mut TestAppContext,
  52    cx_b: &mut TestAppContext,
  53    cx_b2: &mut TestAppContext,
  54    cx_c: &mut TestAppContext,
  55) {
  56    let mut server = TestServer::start(executor.clone()).await;
  57
  58    let client_a = server.create_client(cx_a, "user_a").await;
  59    let client_b = server.create_client(cx_b, "user_b").await;
  60    let client_c = server.create_client(cx_c, "user_c").await;
  61    server
  62        .make_contacts(&mut [(&client_a, cx_a), (&client_b, cx_b), (&client_c, cx_c)])
  63        .await;
  64
  65    let active_call_a = cx_a.read(ActiveCall::global);
  66    let active_call_b = cx_b.read(ActiveCall::global);
  67    let active_call_c = cx_c.read(ActiveCall::global);
  68
  69    // Call user B from client A.
  70    active_call_a
  71        .update(cx_a, |call, cx| {
  72            call.invite(client_b.user_id().unwrap(), None, cx)
  73        })
  74        .await
  75        .unwrap();
  76    let room_a = active_call_a.read_with(cx_a, |call, _| call.room().unwrap().clone());
  77    executor.run_until_parked();
  78    assert_eq!(
  79        room_participants(&room_a, cx_a),
  80        RoomParticipants {
  81            remote: Default::default(),
  82            pending: vec!["user_b".to_string()]
  83        }
  84    );
  85
  86    // User B receives the call.
  87
  88    let mut incoming_call_b = active_call_b.read_with(cx_b, |call, _| call.incoming());
  89    let call_b = incoming_call_b.next().await.unwrap().unwrap();
  90    assert_eq!(call_b.calling_user.github_login, "user_a");
  91
  92    // User B connects via another client and also receives a ring on the newly-connected client.
  93    let _client_b2 = server.create_client(cx_b2, "user_b").await;
  94    let active_call_b2 = cx_b2.read(ActiveCall::global);
  95
  96    let mut incoming_call_b2 = active_call_b2.read_with(cx_b2, |call, _| call.incoming());
  97    executor.run_until_parked();
  98    let call_b2 = incoming_call_b2.next().await.unwrap().unwrap();
  99    assert_eq!(call_b2.calling_user.github_login, "user_a");
 100
 101    // User B joins the room using the first client.
 102    active_call_b
 103        .update(cx_b, |call, cx| call.accept_incoming(cx))
 104        .await
 105        .unwrap();
 106
 107    let room_b = active_call_b.read_with(cx_b, |call, _| call.room().unwrap().clone());
 108    assert!(incoming_call_b.next().await.unwrap().is_none());
 109
 110    executor.run_until_parked();
 111    assert_eq!(
 112        room_participants(&room_a, cx_a),
 113        RoomParticipants {
 114            remote: vec!["user_b".to_string()],
 115            pending: Default::default()
 116        }
 117    );
 118    assert_eq!(
 119        room_participants(&room_b, cx_b),
 120        RoomParticipants {
 121            remote: vec!["user_a".to_string()],
 122            pending: Default::default()
 123        }
 124    );
 125
 126    // Call user C from client B.
 127
 128    let mut incoming_call_c = active_call_c.read_with(cx_c, |call, _| call.incoming());
 129    active_call_b
 130        .update(cx_b, |call, cx| {
 131            call.invite(client_c.user_id().unwrap(), None, cx)
 132        })
 133        .await
 134        .unwrap();
 135
 136    executor.run_until_parked();
 137    assert_eq!(
 138        room_participants(&room_a, cx_a),
 139        RoomParticipants {
 140            remote: vec!["user_b".to_string()],
 141            pending: vec!["user_c".to_string()]
 142        }
 143    );
 144    assert_eq!(
 145        room_participants(&room_b, cx_b),
 146        RoomParticipants {
 147            remote: vec!["user_a".to_string()],
 148            pending: vec!["user_c".to_string()]
 149        }
 150    );
 151
 152    // User C receives the call, but declines it.
 153    let call_c = incoming_call_c.next().await.unwrap().unwrap();
 154    assert_eq!(call_c.calling_user.github_login, "user_b");
 155    active_call_c.update(cx_c, |call, cx| call.decline_incoming(cx).unwrap());
 156    assert!(incoming_call_c.next().await.unwrap().is_none());
 157
 158    executor.run_until_parked();
 159    assert_eq!(
 160        room_participants(&room_a, cx_a),
 161        RoomParticipants {
 162            remote: vec!["user_b".to_string()],
 163            pending: Default::default()
 164        }
 165    );
 166    assert_eq!(
 167        room_participants(&room_b, cx_b),
 168        RoomParticipants {
 169            remote: vec!["user_a".to_string()],
 170            pending: Default::default()
 171        }
 172    );
 173
 174    // Call user C again from user A.
 175    active_call_a
 176        .update(cx_a, |call, cx| {
 177            call.invite(client_c.user_id().unwrap(), None, cx)
 178        })
 179        .await
 180        .unwrap();
 181
 182    executor.run_until_parked();
 183    assert_eq!(
 184        room_participants(&room_a, cx_a),
 185        RoomParticipants {
 186            remote: vec!["user_b".to_string()],
 187            pending: vec!["user_c".to_string()]
 188        }
 189    );
 190    assert_eq!(
 191        room_participants(&room_b, cx_b),
 192        RoomParticipants {
 193            remote: vec!["user_a".to_string()],
 194            pending: vec!["user_c".to_string()]
 195        }
 196    );
 197
 198    // User C accepts the call.
 199    let call_c = incoming_call_c.next().await.unwrap().unwrap();
 200    assert_eq!(call_c.calling_user.github_login, "user_a");
 201    active_call_c
 202        .update(cx_c, |call, cx| call.accept_incoming(cx))
 203        .await
 204        .unwrap();
 205    assert!(incoming_call_c.next().await.unwrap().is_none());
 206
 207    let room_c = active_call_c.read_with(cx_c, |call, _| call.room().unwrap().clone());
 208
 209    executor.run_until_parked();
 210    assert_eq!(
 211        room_participants(&room_a, cx_a),
 212        RoomParticipants {
 213            remote: vec!["user_b".to_string(), "user_c".to_string()],
 214            pending: Default::default()
 215        }
 216    );
 217    assert_eq!(
 218        room_participants(&room_b, cx_b),
 219        RoomParticipants {
 220            remote: vec!["user_a".to_string(), "user_c".to_string()],
 221            pending: Default::default()
 222        }
 223    );
 224    assert_eq!(
 225        room_participants(&room_c, cx_c),
 226        RoomParticipants {
 227            remote: vec!["user_a".to_string(), "user_b".to_string()],
 228            pending: Default::default()
 229        }
 230    );
 231
 232    // User A shares their screen
 233    let display = MacOSDisplay::new();
 234    let events_b = active_call_events(cx_b);
 235    let events_c = active_call_events(cx_c);
 236    active_call_a
 237        .update(cx_a, |call, cx| {
 238            call.room().unwrap().update(cx, |room, cx| {
 239                room.set_display_sources(vec![display.clone()]);
 240                room.share_screen(cx)
 241            })
 242        })
 243        .await
 244        .unwrap();
 245
 246    executor.run_until_parked();
 247
 248    // User B observes the remote screen sharing track.
 249    assert_eq!(events_b.borrow().len(), 1);
 250    let event_b = events_b.borrow().first().unwrap().clone();
 251    if let call::room::Event::RemoteVideoTracksChanged { participant_id } = event_b {
 252        assert_eq!(participant_id, client_a.peer_id().unwrap());
 253
 254        room_b.read_with(cx_b, |room, _| {
 255            assert_eq!(
 256                room.remote_participants()[&client_a.user_id().unwrap()]
 257                    .video_tracks
 258                    .len(),
 259                1
 260            );
 261        });
 262    } else {
 263        panic!("unexpected event")
 264    }
 265
 266    // User C observes the remote screen sharing track.
 267    assert_eq!(events_c.borrow().len(), 1);
 268    let event_c = events_c.borrow().first().unwrap().clone();
 269    if let call::room::Event::RemoteVideoTracksChanged { participant_id } = event_c {
 270        assert_eq!(participant_id, client_a.peer_id().unwrap());
 271
 272        room_c.read_with(cx_c, |room, _| {
 273            assert_eq!(
 274                room.remote_participants()[&client_a.user_id().unwrap()]
 275                    .video_tracks
 276                    .len(),
 277                1
 278            );
 279        });
 280    } else {
 281        panic!("unexpected event")
 282    }
 283
 284    // User A leaves the room.
 285    active_call_a
 286        .update(cx_a, |call, cx| {
 287            let hang_up = call.hang_up(cx);
 288            assert!(call.room().is_none());
 289            hang_up
 290        })
 291        .await
 292        .unwrap();
 293    executor.run_until_parked();
 294    assert_eq!(
 295        room_participants(&room_a, cx_a),
 296        RoomParticipants {
 297            remote: Default::default(),
 298            pending: Default::default()
 299        }
 300    );
 301    assert_eq!(
 302        room_participants(&room_b, cx_b),
 303        RoomParticipants {
 304            remote: vec!["user_c".to_string()],
 305            pending: Default::default()
 306        }
 307    );
 308    assert_eq!(
 309        room_participants(&room_c, cx_c),
 310        RoomParticipants {
 311            remote: vec!["user_b".to_string()],
 312            pending: Default::default()
 313        }
 314    );
 315
 316    // User B gets disconnected from the LiveKit server, which causes them
 317    // to automatically leave the room. User C leaves the room as well because
 318    // nobody else is in there.
 319    server
 320        .test_live_kit_server
 321        .disconnect_client(client_b.user_id().unwrap().to_string())
 322        .await;
 323    executor.run_until_parked();
 324
 325    active_call_b.read_with(cx_b, |call, _| assert!(call.room().is_none()));
 326
 327    active_call_c.read_with(cx_c, |call, _| assert!(call.room().is_none()));
 328    assert_eq!(
 329        room_participants(&room_a, cx_a),
 330        RoomParticipants {
 331            remote: Default::default(),
 332            pending: Default::default()
 333        }
 334    );
 335    assert_eq!(
 336        room_participants(&room_b, cx_b),
 337        RoomParticipants {
 338            remote: Default::default(),
 339            pending: Default::default()
 340        }
 341    );
 342    assert_eq!(
 343        room_participants(&room_c, cx_c),
 344        RoomParticipants {
 345            remote: Default::default(),
 346            pending: Default::default()
 347        }
 348    );
 349}
 350
 351#[gpui::test(iterations = 10)]
 352async fn test_calling_multiple_users_simultaneously(
 353    executor: BackgroundExecutor,
 354    cx_a: &mut TestAppContext,
 355    cx_b: &mut TestAppContext,
 356    cx_c: &mut TestAppContext,
 357    cx_d: &mut TestAppContext,
 358) {
 359    let mut server = TestServer::start(executor.clone()).await;
 360
 361    let client_a = server.create_client(cx_a, "user_a").await;
 362    let client_b = server.create_client(cx_b, "user_b").await;
 363    let client_c = server.create_client(cx_c, "user_c").await;
 364    let client_d = server.create_client(cx_d, "user_d").await;
 365    server
 366        .make_contacts(&mut [
 367            (&client_a, cx_a),
 368            (&client_b, cx_b),
 369            (&client_c, cx_c),
 370            (&client_d, cx_d),
 371        ])
 372        .await;
 373
 374    let active_call_a = cx_a.read(ActiveCall::global);
 375    let active_call_b = cx_b.read(ActiveCall::global);
 376    let active_call_c = cx_c.read(ActiveCall::global);
 377    let active_call_d = cx_d.read(ActiveCall::global);
 378
 379    // Simultaneously call user B and user C from client A.
 380    let b_invite = active_call_a.update(cx_a, |call, cx| {
 381        call.invite(client_b.user_id().unwrap(), None, cx)
 382    });
 383    let c_invite = active_call_a.update(cx_a, |call, cx| {
 384        call.invite(client_c.user_id().unwrap(), None, cx)
 385    });
 386    b_invite.await.unwrap();
 387    c_invite.await.unwrap();
 388
 389    let room_a = active_call_a.read_with(cx_a, |call, _| call.room().unwrap().clone());
 390    executor.run_until_parked();
 391    assert_eq!(
 392        room_participants(&room_a, cx_a),
 393        RoomParticipants {
 394            remote: Default::default(),
 395            pending: vec!["user_b".to_string(), "user_c".to_string()]
 396        }
 397    );
 398
 399    // Call client D from client A.
 400    active_call_a
 401        .update(cx_a, |call, cx| {
 402            call.invite(client_d.user_id().unwrap(), None, cx)
 403        })
 404        .await
 405        .unwrap();
 406    executor.run_until_parked();
 407    assert_eq!(
 408        room_participants(&room_a, cx_a),
 409        RoomParticipants {
 410            remote: Default::default(),
 411            pending: vec![
 412                "user_b".to_string(),
 413                "user_c".to_string(),
 414                "user_d".to_string()
 415            ]
 416        }
 417    );
 418
 419    // Accept the call on all clients simultaneously.
 420    let accept_b = active_call_b.update(cx_b, |call, cx| call.accept_incoming(cx));
 421    let accept_c = active_call_c.update(cx_c, |call, cx| call.accept_incoming(cx));
 422    let accept_d = active_call_d.update(cx_d, |call, cx| call.accept_incoming(cx));
 423    accept_b.await.unwrap();
 424    accept_c.await.unwrap();
 425    accept_d.await.unwrap();
 426
 427    executor.run_until_parked();
 428
 429    let room_b = active_call_b.read_with(cx_b, |call, _| call.room().unwrap().clone());
 430
 431    let room_c = active_call_c.read_with(cx_c, |call, _| call.room().unwrap().clone());
 432
 433    let room_d = active_call_d.read_with(cx_d, |call, _| call.room().unwrap().clone());
 434    assert_eq!(
 435        room_participants(&room_a, cx_a),
 436        RoomParticipants {
 437            remote: vec![
 438                "user_b".to_string(),
 439                "user_c".to_string(),
 440                "user_d".to_string(),
 441            ],
 442            pending: Default::default()
 443        }
 444    );
 445    assert_eq!(
 446        room_participants(&room_b, cx_b),
 447        RoomParticipants {
 448            remote: vec![
 449                "user_a".to_string(),
 450                "user_c".to_string(),
 451                "user_d".to_string(),
 452            ],
 453            pending: Default::default()
 454        }
 455    );
 456    assert_eq!(
 457        room_participants(&room_c, cx_c),
 458        RoomParticipants {
 459            remote: vec![
 460                "user_a".to_string(),
 461                "user_b".to_string(),
 462                "user_d".to_string(),
 463            ],
 464            pending: Default::default()
 465        }
 466    );
 467    assert_eq!(
 468        room_participants(&room_d, cx_d),
 469        RoomParticipants {
 470            remote: vec![
 471                "user_a".to_string(),
 472                "user_b".to_string(),
 473                "user_c".to_string(),
 474            ],
 475            pending: Default::default()
 476        }
 477    );
 478}
 479
 480#[gpui::test(iterations = 10)]
 481async fn test_joining_channels_and_calling_multiple_users_simultaneously(
 482    executor: BackgroundExecutor,
 483    cx_a: &mut TestAppContext,
 484    cx_b: &mut TestAppContext,
 485    cx_c: &mut TestAppContext,
 486) {
 487    let mut server = TestServer::start(executor.clone()).await;
 488
 489    let client_a = server.create_client(cx_a, "user_a").await;
 490    let client_b = server.create_client(cx_b, "user_b").await;
 491    let client_c = server.create_client(cx_c, "user_c").await;
 492    server
 493        .make_contacts(&mut [(&client_a, cx_a), (&client_b, cx_b), (&client_c, cx_c)])
 494        .await;
 495
 496    let channel_1 = server
 497        .make_channel(
 498            "channel1",
 499            None,
 500            (&client_a, cx_a),
 501            &mut [(&client_b, cx_b), (&client_c, cx_c)],
 502        )
 503        .await;
 504
 505    let channel_2 = server
 506        .make_channel(
 507            "channel2",
 508            None,
 509            (&client_a, cx_a),
 510            &mut [(&client_b, cx_b), (&client_c, cx_c)],
 511        )
 512        .await;
 513
 514    let active_call_a = cx_a.read(ActiveCall::global);
 515
 516    // Simultaneously join channel 1 and then channel 2
 517    active_call_a
 518        .update(cx_a, |call, cx| call.join_channel(channel_1, cx))
 519        .detach();
 520    let join_channel_2 = active_call_a.update(cx_a, |call, cx| call.join_channel(channel_2, cx));
 521
 522    join_channel_2.await.unwrap();
 523
 524    let room_a = active_call_a.read_with(cx_a, |call, _| call.room().unwrap().clone());
 525    executor.run_until_parked();
 526
 527    assert_eq!(channel_id(&room_a, cx_a), Some(channel_2));
 528
 529    // Leave the room
 530    active_call_a
 531        .update(cx_a, |call, cx| {
 532            let hang_up = call.hang_up(cx);
 533            hang_up
 534        })
 535        .await
 536        .unwrap();
 537
 538    // Initiating invites and then joining a channel should fail gracefully
 539    let b_invite = active_call_a.update(cx_a, |call, cx| {
 540        call.invite(client_b.user_id().unwrap(), None, cx)
 541    });
 542    let c_invite = active_call_a.update(cx_a, |call, cx| {
 543        call.invite(client_c.user_id().unwrap(), None, cx)
 544    });
 545
 546    let join_channel = active_call_a.update(cx_a, |call, cx| call.join_channel(channel_1, cx));
 547
 548    b_invite.await.unwrap();
 549    c_invite.await.unwrap();
 550    join_channel.await.unwrap();
 551
 552    let room_a = active_call_a.read_with(cx_a, |call, _| call.room().unwrap().clone());
 553    executor.run_until_parked();
 554
 555    assert_eq!(
 556        room_participants(&room_a, cx_a),
 557        RoomParticipants {
 558            remote: Default::default(),
 559            pending: vec!["user_b".to_string(), "user_c".to_string()]
 560        }
 561    );
 562
 563    assert_eq!(channel_id(&room_a, cx_a), None);
 564
 565    // Leave the room
 566    active_call_a
 567        .update(cx_a, |call, cx| {
 568            let hang_up = call.hang_up(cx);
 569            hang_up
 570        })
 571        .await
 572        .unwrap();
 573
 574    // Simultaneously join channel 1 and call user B and user C from client A.
 575    let join_channel = active_call_a.update(cx_a, |call, cx| call.join_channel(channel_1, cx));
 576
 577    let b_invite = active_call_a.update(cx_a, |call, cx| {
 578        call.invite(client_b.user_id().unwrap(), None, cx)
 579    });
 580    let c_invite = active_call_a.update(cx_a, |call, cx| {
 581        call.invite(client_c.user_id().unwrap(), None, cx)
 582    });
 583
 584    join_channel.await.unwrap();
 585    b_invite.await.unwrap();
 586    c_invite.await.unwrap();
 587
 588    active_call_a.read_with(cx_a, |call, _| call.room().unwrap().clone());
 589    executor.run_until_parked();
 590}
 591
 592#[gpui::test(iterations = 10)]
 593async fn test_room_uniqueness(
 594    executor: BackgroundExecutor,
 595    cx_a: &mut TestAppContext,
 596    cx_a2: &mut TestAppContext,
 597    cx_b: &mut TestAppContext,
 598    cx_b2: &mut TestAppContext,
 599    cx_c: &mut TestAppContext,
 600) {
 601    let mut server = TestServer::start(executor.clone()).await;
 602    let client_a = server.create_client(cx_a, "user_a").await;
 603    let _client_a2 = server.create_client(cx_a2, "user_a").await;
 604    let client_b = server.create_client(cx_b, "user_b").await;
 605    let _client_b2 = server.create_client(cx_b2, "user_b").await;
 606    let client_c = server.create_client(cx_c, "user_c").await;
 607    server
 608        .make_contacts(&mut [(&client_a, cx_a), (&client_b, cx_b), (&client_c, cx_c)])
 609        .await;
 610
 611    let active_call_a = cx_a.read(ActiveCall::global);
 612    let active_call_a2 = cx_a2.read(ActiveCall::global);
 613    let active_call_b = cx_b.read(ActiveCall::global);
 614    let active_call_b2 = cx_b2.read(ActiveCall::global);
 615    let active_call_c = cx_c.read(ActiveCall::global);
 616
 617    // Call user B from client A.
 618    active_call_a
 619        .update(cx_a, |call, cx| {
 620            call.invite(client_b.user_id().unwrap(), None, cx)
 621        })
 622        .await
 623        .unwrap();
 624
 625    // Ensure a new room can't be created given user A just created one.
 626    active_call_a2
 627        .update(cx_a2, |call, cx| {
 628            call.invite(client_c.user_id().unwrap(), None, cx)
 629        })
 630        .await
 631        .unwrap_err();
 632
 633    active_call_a2.read_with(cx_a2, |call, _| assert!(call.room().is_none()));
 634
 635    // User B receives the call from user A.
 636
 637    let mut incoming_call_b = active_call_b.read_with(cx_b, |call, _| call.incoming());
 638    let call_b1 = incoming_call_b.next().await.unwrap().unwrap();
 639    assert_eq!(call_b1.calling_user.github_login, "user_a");
 640
 641    // Ensure calling users A and B from client C fails.
 642    active_call_c
 643        .update(cx_c, |call, cx| {
 644            call.invite(client_a.user_id().unwrap(), None, cx)
 645        })
 646        .await
 647        .unwrap_err();
 648    active_call_c
 649        .update(cx_c, |call, cx| {
 650            call.invite(client_b.user_id().unwrap(), None, cx)
 651        })
 652        .await
 653        .unwrap_err();
 654
 655    // Ensure User B can't create a room while they still have an incoming call.
 656    active_call_b2
 657        .update(cx_b2, |call, cx| {
 658            call.invite(client_c.user_id().unwrap(), None, cx)
 659        })
 660        .await
 661        .unwrap_err();
 662
 663    active_call_b2.read_with(cx_b2, |call, _| assert!(call.room().is_none()));
 664
 665    // User B joins the room and calling them after they've joined still fails.
 666    active_call_b
 667        .update(cx_b, |call, cx| call.accept_incoming(cx))
 668        .await
 669        .unwrap();
 670    active_call_c
 671        .update(cx_c, |call, cx| {
 672            call.invite(client_b.user_id().unwrap(), None, cx)
 673        })
 674        .await
 675        .unwrap_err();
 676
 677    // Ensure User B can't create a room while they belong to another room.
 678    active_call_b2
 679        .update(cx_b2, |call, cx| {
 680            call.invite(client_c.user_id().unwrap(), None, cx)
 681        })
 682        .await
 683        .unwrap_err();
 684
 685    active_call_b2.read_with(cx_b2, |call, _| assert!(call.room().is_none()));
 686
 687    // Client C can successfully call client B after client B leaves the room.
 688    active_call_b
 689        .update(cx_b, |call, cx| call.hang_up(cx))
 690        .await
 691        .unwrap();
 692    executor.run_until_parked();
 693    active_call_c
 694        .update(cx_c, |call, cx| {
 695            call.invite(client_b.user_id().unwrap(), None, cx)
 696        })
 697        .await
 698        .unwrap();
 699    executor.run_until_parked();
 700    let call_b2 = incoming_call_b.next().await.unwrap().unwrap();
 701    assert_eq!(call_b2.calling_user.github_login, "user_c");
 702}
 703
 704#[gpui::test(iterations = 10)]
 705async fn test_client_disconnecting_from_room(
 706    executor: BackgroundExecutor,
 707    cx_a: &mut TestAppContext,
 708    cx_b: &mut TestAppContext,
 709) {
 710    let mut server = TestServer::start(executor.clone()).await;
 711    let client_a = server.create_client(cx_a, "user_a").await;
 712    let client_b = server.create_client(cx_b, "user_b").await;
 713    server
 714        .make_contacts(&mut [(&client_a, cx_a), (&client_b, cx_b)])
 715        .await;
 716
 717    let active_call_a = cx_a.read(ActiveCall::global);
 718    let active_call_b = cx_b.read(ActiveCall::global);
 719
 720    // Call user B from client A.
 721    active_call_a
 722        .update(cx_a, |call, cx| {
 723            call.invite(client_b.user_id().unwrap(), None, cx)
 724        })
 725        .await
 726        .unwrap();
 727
 728    let room_a = active_call_a.read_with(cx_a, |call, _| call.room().unwrap().clone());
 729
 730    // User B receives the call and joins the room.
 731
 732    let mut incoming_call_b = active_call_b.read_with(cx_b, |call, _| call.incoming());
 733    incoming_call_b.next().await.unwrap().unwrap();
 734    active_call_b
 735        .update(cx_b, |call, cx| call.accept_incoming(cx))
 736        .await
 737        .unwrap();
 738
 739    let room_b = active_call_b.read_with(cx_b, |call, _| call.room().unwrap().clone());
 740    executor.run_until_parked();
 741    assert_eq!(
 742        room_participants(&room_a, cx_a),
 743        RoomParticipants {
 744            remote: vec!["user_b".to_string()],
 745            pending: Default::default()
 746        }
 747    );
 748    assert_eq!(
 749        room_participants(&room_b, cx_b),
 750        RoomParticipants {
 751            remote: vec!["user_a".to_string()],
 752            pending: Default::default()
 753        }
 754    );
 755
 756    // User A automatically reconnects to the room upon disconnection.
 757    server.disconnect_client(client_a.peer_id().unwrap());
 758    executor.advance_clock(RECEIVE_TIMEOUT);
 759    executor.run_until_parked();
 760    assert_eq!(
 761        room_participants(&room_a, cx_a),
 762        RoomParticipants {
 763            remote: vec!["user_b".to_string()],
 764            pending: Default::default()
 765        }
 766    );
 767    assert_eq!(
 768        room_participants(&room_b, cx_b),
 769        RoomParticipants {
 770            remote: vec!["user_a".to_string()],
 771            pending: Default::default()
 772        }
 773    );
 774
 775    // When user A disconnects, both client A and B clear their room on the active call.
 776    server.forbid_connections();
 777    server.disconnect_client(client_a.peer_id().unwrap());
 778    executor.advance_clock(RECEIVE_TIMEOUT + RECONNECT_TIMEOUT);
 779
 780    active_call_a.read_with(cx_a, |call, _| assert!(call.room().is_none()));
 781
 782    active_call_b.read_with(cx_b, |call, _| assert!(call.room().is_none()));
 783    assert_eq!(
 784        room_participants(&room_a, cx_a),
 785        RoomParticipants {
 786            remote: Default::default(),
 787            pending: Default::default()
 788        }
 789    );
 790    assert_eq!(
 791        room_participants(&room_b, cx_b),
 792        RoomParticipants {
 793            remote: Default::default(),
 794            pending: Default::default()
 795        }
 796    );
 797
 798    // Allow user A to reconnect to the server.
 799    server.allow_connections();
 800    executor.advance_clock(RECEIVE_TIMEOUT);
 801
 802    // Call user B again from client A.
 803    active_call_a
 804        .update(cx_a, |call, cx| {
 805            call.invite(client_b.user_id().unwrap(), None, cx)
 806        })
 807        .await
 808        .unwrap();
 809
 810    let room_a = active_call_a.read_with(cx_a, |call, _| call.room().unwrap().clone());
 811
 812    // User B receives the call and joins the room.
 813
 814    let mut incoming_call_b = active_call_b.read_with(cx_b, |call, _| call.incoming());
 815    incoming_call_b.next().await.unwrap().unwrap();
 816    active_call_b
 817        .update(cx_b, |call, cx| call.accept_incoming(cx))
 818        .await
 819        .unwrap();
 820
 821    let room_b = active_call_b.read_with(cx_b, |call, _| call.room().unwrap().clone());
 822    executor.run_until_parked();
 823    assert_eq!(
 824        room_participants(&room_a, cx_a),
 825        RoomParticipants {
 826            remote: vec!["user_b".to_string()],
 827            pending: Default::default()
 828        }
 829    );
 830    assert_eq!(
 831        room_participants(&room_b, cx_b),
 832        RoomParticipants {
 833            remote: vec!["user_a".to_string()],
 834            pending: Default::default()
 835        }
 836    );
 837
 838    // User B gets disconnected from the LiveKit server, which causes it
 839    // to automatically leave the room.
 840    server
 841        .test_live_kit_server
 842        .disconnect_client(client_b.user_id().unwrap().to_string())
 843        .await;
 844    executor.run_until_parked();
 845    active_call_a.update(cx_a, |call, _| assert!(call.room().is_none()));
 846    active_call_b.update(cx_b, |call, _| assert!(call.room().is_none()));
 847    assert_eq!(
 848        room_participants(&room_a, cx_a),
 849        RoomParticipants {
 850            remote: Default::default(),
 851            pending: Default::default()
 852        }
 853    );
 854    assert_eq!(
 855        room_participants(&room_b, cx_b),
 856        RoomParticipants {
 857            remote: Default::default(),
 858            pending: Default::default()
 859        }
 860    );
 861}
 862
 863#[gpui::test(iterations = 10)]
 864async fn test_server_restarts(
 865    executor: BackgroundExecutor,
 866    cx_a: &mut TestAppContext,
 867    cx_b: &mut TestAppContext,
 868    cx_c: &mut TestAppContext,
 869    cx_d: &mut TestAppContext,
 870) {
 871    let mut server = TestServer::start(executor.clone()).await;
 872    let client_a = server.create_client(cx_a, "user_a").await;
 873    client_a
 874        .fs()
 875        .insert_tree("/a", json!({ "a.txt": "a-contents" }))
 876        .await;
 877
 878    // Invite client B to collaborate on a project
 879    let (project_a, _) = client_a.build_local_project("/a", cx_a).await;
 880
 881    let client_b = server.create_client(cx_b, "user_b").await;
 882    let client_c = server.create_client(cx_c, "user_c").await;
 883    let client_d = server.create_client(cx_d, "user_d").await;
 884    server
 885        .make_contacts(&mut [
 886            (&client_a, cx_a),
 887            (&client_b, cx_b),
 888            (&client_c, cx_c),
 889            (&client_d, cx_d),
 890        ])
 891        .await;
 892
 893    let active_call_a = cx_a.read(ActiveCall::global);
 894    let active_call_b = cx_b.read(ActiveCall::global);
 895    let active_call_c = cx_c.read(ActiveCall::global);
 896    let active_call_d = cx_d.read(ActiveCall::global);
 897
 898    // User A calls users B, C, and D.
 899    active_call_a
 900        .update(cx_a, |call, cx| {
 901            call.invite(client_b.user_id().unwrap(), Some(project_a.clone()), cx)
 902        })
 903        .await
 904        .unwrap();
 905    active_call_a
 906        .update(cx_a, |call, cx| {
 907            call.invite(client_c.user_id().unwrap(), Some(project_a.clone()), cx)
 908        })
 909        .await
 910        .unwrap();
 911    active_call_a
 912        .update(cx_a, |call, cx| {
 913            call.invite(client_d.user_id().unwrap(), Some(project_a.clone()), cx)
 914        })
 915        .await
 916        .unwrap();
 917
 918    let room_a = active_call_a.read_with(cx_a, |call, _| call.room().unwrap().clone());
 919
 920    // User B receives the call and joins the room.
 921
 922    let mut incoming_call_b = active_call_b.read_with(cx_b, |call, _| call.incoming());
 923    assert!(incoming_call_b.next().await.unwrap().is_some());
 924    active_call_b
 925        .update(cx_b, |call, cx| call.accept_incoming(cx))
 926        .await
 927        .unwrap();
 928
 929    let room_b = active_call_b.read_with(cx_b, |call, _| call.room().unwrap().clone());
 930
 931    // User C receives the call and joins the room.
 932
 933    let mut incoming_call_c = active_call_c.read_with(cx_c, |call, _| call.incoming());
 934    assert!(incoming_call_c.next().await.unwrap().is_some());
 935    active_call_c
 936        .update(cx_c, |call, cx| call.accept_incoming(cx))
 937        .await
 938        .unwrap();
 939
 940    let room_c = active_call_c.read_with(cx_c, |call, _| call.room().unwrap().clone());
 941
 942    // User D receives the call but doesn't join the room yet.
 943
 944    let mut incoming_call_d = active_call_d.read_with(cx_d, |call, _| call.incoming());
 945    assert!(incoming_call_d.next().await.unwrap().is_some());
 946
 947    executor.run_until_parked();
 948    assert_eq!(
 949        room_participants(&room_a, cx_a),
 950        RoomParticipants {
 951            remote: vec!["user_b".to_string(), "user_c".to_string()],
 952            pending: vec!["user_d".to_string()]
 953        }
 954    );
 955    assert_eq!(
 956        room_participants(&room_b, cx_b),
 957        RoomParticipants {
 958            remote: vec!["user_a".to_string(), "user_c".to_string()],
 959            pending: vec!["user_d".to_string()]
 960        }
 961    );
 962    assert_eq!(
 963        room_participants(&room_c, cx_c),
 964        RoomParticipants {
 965            remote: vec!["user_a".to_string(), "user_b".to_string()],
 966            pending: vec!["user_d".to_string()]
 967        }
 968    );
 969
 970    // The server is torn down.
 971    server.reset().await;
 972
 973    // Users A and B reconnect to the call. User C has troubles reconnecting, so it leaves the room.
 974    client_c.override_establish_connection(|_, cx| cx.spawn(|_| future::pending()));
 975    executor.advance_clock(RECONNECT_TIMEOUT);
 976    assert_eq!(
 977        room_participants(&room_a, cx_a),
 978        RoomParticipants {
 979            remote: vec!["user_b".to_string(), "user_c".to_string()],
 980            pending: vec!["user_d".to_string()]
 981        }
 982    );
 983    assert_eq!(
 984        room_participants(&room_b, cx_b),
 985        RoomParticipants {
 986            remote: vec!["user_a".to_string(), "user_c".to_string()],
 987            pending: vec!["user_d".to_string()]
 988        }
 989    );
 990    assert_eq!(
 991        room_participants(&room_c, cx_c),
 992        RoomParticipants {
 993            remote: vec![],
 994            pending: vec![]
 995        }
 996    );
 997
 998    // User D is notified again of the incoming call and accepts it.
 999    assert!(incoming_call_d.next().await.unwrap().is_some());
1000    active_call_d
1001        .update(cx_d, |call, cx| call.accept_incoming(cx))
1002        .await
1003        .unwrap();
1004    executor.run_until_parked();
1005
1006    let room_d = active_call_d.read_with(cx_d, |call, _| call.room().unwrap().clone());
1007    assert_eq!(
1008        room_participants(&room_a, cx_a),
1009        RoomParticipants {
1010            remote: vec![
1011                "user_b".to_string(),
1012                "user_c".to_string(),
1013                "user_d".to_string(),
1014            ],
1015            pending: vec![]
1016        }
1017    );
1018    assert_eq!(
1019        room_participants(&room_b, cx_b),
1020        RoomParticipants {
1021            remote: vec![
1022                "user_a".to_string(),
1023                "user_c".to_string(),
1024                "user_d".to_string(),
1025            ],
1026            pending: vec![]
1027        }
1028    );
1029    assert_eq!(
1030        room_participants(&room_c, cx_c),
1031        RoomParticipants {
1032            remote: vec![],
1033            pending: vec![]
1034        }
1035    );
1036    assert_eq!(
1037        room_participants(&room_d, cx_d),
1038        RoomParticipants {
1039            remote: vec![
1040                "user_a".to_string(),
1041                "user_b".to_string(),
1042                "user_c".to_string(),
1043            ],
1044            pending: vec![]
1045        }
1046    );
1047
1048    // The server finishes restarting, cleaning up stale connections.
1049    server.start().await.unwrap();
1050    executor.advance_clock(CLEANUP_TIMEOUT);
1051    assert_eq!(
1052        room_participants(&room_a, cx_a),
1053        RoomParticipants {
1054            remote: vec!["user_b".to_string(), "user_d".to_string()],
1055            pending: vec![]
1056        }
1057    );
1058    assert_eq!(
1059        room_participants(&room_b, cx_b),
1060        RoomParticipants {
1061            remote: vec!["user_a".to_string(), "user_d".to_string()],
1062            pending: vec![]
1063        }
1064    );
1065    assert_eq!(
1066        room_participants(&room_c, cx_c),
1067        RoomParticipants {
1068            remote: vec![],
1069            pending: vec![]
1070        }
1071    );
1072    assert_eq!(
1073        room_participants(&room_d, cx_d),
1074        RoomParticipants {
1075            remote: vec!["user_a".to_string(), "user_b".to_string()],
1076            pending: vec![]
1077        }
1078    );
1079
1080    // User D hangs up.
1081    active_call_d
1082        .update(cx_d, |call, cx| call.hang_up(cx))
1083        .await
1084        .unwrap();
1085    executor.run_until_parked();
1086    assert_eq!(
1087        room_participants(&room_a, cx_a),
1088        RoomParticipants {
1089            remote: vec!["user_b".to_string()],
1090            pending: vec![]
1091        }
1092    );
1093    assert_eq!(
1094        room_participants(&room_b, cx_b),
1095        RoomParticipants {
1096            remote: vec!["user_a".to_string()],
1097            pending: vec![]
1098        }
1099    );
1100    assert_eq!(
1101        room_participants(&room_c, cx_c),
1102        RoomParticipants {
1103            remote: vec![],
1104            pending: vec![]
1105        }
1106    );
1107    assert_eq!(
1108        room_participants(&room_d, cx_d),
1109        RoomParticipants {
1110            remote: vec![],
1111            pending: vec![]
1112        }
1113    );
1114
1115    // User B calls user D again.
1116    active_call_b
1117        .update(cx_b, |call, cx| {
1118            call.invite(client_d.user_id().unwrap(), None, cx)
1119        })
1120        .await
1121        .unwrap();
1122
1123    // User D receives the call but doesn't join the room yet.
1124
1125    let mut incoming_call_d = active_call_d.read_with(cx_d, |call, _| call.incoming());
1126    assert!(incoming_call_d.next().await.unwrap().is_some());
1127    executor.run_until_parked();
1128    assert_eq!(
1129        room_participants(&room_a, cx_a),
1130        RoomParticipants {
1131            remote: vec!["user_b".to_string()],
1132            pending: vec!["user_d".to_string()]
1133        }
1134    );
1135    assert_eq!(
1136        room_participants(&room_b, cx_b),
1137        RoomParticipants {
1138            remote: vec!["user_a".to_string()],
1139            pending: vec!["user_d".to_string()]
1140        }
1141    );
1142
1143    // The server is torn down.
1144    server.reset().await;
1145
1146    // Users A and B have troubles reconnecting, so they leave the room.
1147    client_a.override_establish_connection(|_, cx| cx.spawn(|_| future::pending()));
1148    client_b.override_establish_connection(|_, cx| cx.spawn(|_| future::pending()));
1149    client_c.override_establish_connection(|_, cx| cx.spawn(|_| future::pending()));
1150    executor.advance_clock(RECONNECT_TIMEOUT);
1151    assert_eq!(
1152        room_participants(&room_a, cx_a),
1153        RoomParticipants {
1154            remote: vec![],
1155            pending: vec![]
1156        }
1157    );
1158    assert_eq!(
1159        room_participants(&room_b, cx_b),
1160        RoomParticipants {
1161            remote: vec![],
1162            pending: vec![]
1163        }
1164    );
1165
1166    // User D is notified again of the incoming call but doesn't accept it.
1167    assert!(incoming_call_d.next().await.unwrap().is_some());
1168
1169    // The server finishes restarting, cleaning up stale connections and canceling the
1170    // call to user D because the room has become empty.
1171    server.start().await.unwrap();
1172    executor.advance_clock(CLEANUP_TIMEOUT);
1173    assert!(incoming_call_d.next().await.unwrap().is_none());
1174}
1175
1176#[gpui::test(iterations = 10)]
1177async fn test_calls_on_multiple_connections(
1178    executor: BackgroundExecutor,
1179    cx_a: &mut TestAppContext,
1180    cx_b1: &mut TestAppContext,
1181    cx_b2: &mut TestAppContext,
1182) {
1183    let mut server = TestServer::start(executor.clone()).await;
1184    let client_a = server.create_client(cx_a, "user_a").await;
1185    let client_b1 = server.create_client(cx_b1, "user_b").await;
1186    let client_b2 = server.create_client(cx_b2, "user_b").await;
1187    server
1188        .make_contacts(&mut [(&client_a, cx_a), (&client_b1, cx_b1)])
1189        .await;
1190
1191    let active_call_a = cx_a.read(ActiveCall::global);
1192    let active_call_b1 = cx_b1.read(ActiveCall::global);
1193    let active_call_b2 = cx_b2.read(ActiveCall::global);
1194
1195    let mut incoming_call_b1 = active_call_b1.read_with(cx_b1, |call, _| call.incoming());
1196
1197    let mut incoming_call_b2 = active_call_b2.read_with(cx_b2, |call, _| call.incoming());
1198    assert!(incoming_call_b1.next().await.unwrap().is_none());
1199    assert!(incoming_call_b2.next().await.unwrap().is_none());
1200
1201    // Call user B from client A, ensuring both clients for user B ring.
1202    active_call_a
1203        .update(cx_a, |call, cx| {
1204            call.invite(client_b1.user_id().unwrap(), None, cx)
1205        })
1206        .await
1207        .unwrap();
1208    executor.run_until_parked();
1209    assert!(incoming_call_b1.next().await.unwrap().is_some());
1210    assert!(incoming_call_b2.next().await.unwrap().is_some());
1211
1212    // User B declines the call on one of the two connections, causing both connections
1213    // to stop ringing.
1214    active_call_b2.update(cx_b2, |call, cx| call.decline_incoming(cx).unwrap());
1215    executor.run_until_parked();
1216    assert!(incoming_call_b1.next().await.unwrap().is_none());
1217    assert!(incoming_call_b2.next().await.unwrap().is_none());
1218
1219    // Call user B again from client A.
1220    active_call_a
1221        .update(cx_a, |call, cx| {
1222            call.invite(client_b1.user_id().unwrap(), None, cx)
1223        })
1224        .await
1225        .unwrap();
1226    executor.run_until_parked();
1227    assert!(incoming_call_b1.next().await.unwrap().is_some());
1228    assert!(incoming_call_b2.next().await.unwrap().is_some());
1229
1230    // User B accepts the call on one of the two connections, causing both connections
1231    // to stop ringing.
1232    active_call_b2
1233        .update(cx_b2, |call, cx| call.accept_incoming(cx))
1234        .await
1235        .unwrap();
1236    executor.run_until_parked();
1237    assert!(incoming_call_b1.next().await.unwrap().is_none());
1238    assert!(incoming_call_b2.next().await.unwrap().is_none());
1239
1240    // User B disconnects the client that is not on the call. Everything should be fine.
1241    client_b1.disconnect(&cx_b1.to_async());
1242    executor.advance_clock(RECEIVE_TIMEOUT);
1243    client_b1
1244        .authenticate_and_connect(false, &cx_b1.to_async())
1245        .await
1246        .unwrap();
1247
1248    // User B hangs up, and user A calls them again.
1249    active_call_b2
1250        .update(cx_b2, |call, cx| call.hang_up(cx))
1251        .await
1252        .unwrap();
1253    executor.run_until_parked();
1254    active_call_a
1255        .update(cx_a, |call, cx| {
1256            call.invite(client_b1.user_id().unwrap(), None, cx)
1257        })
1258        .await
1259        .unwrap();
1260    executor.run_until_parked();
1261    assert!(incoming_call_b1.next().await.unwrap().is_some());
1262    assert!(incoming_call_b2.next().await.unwrap().is_some());
1263
1264    // User A cancels the call, causing both connections to stop ringing.
1265    active_call_a
1266        .update(cx_a, |call, cx| {
1267            call.cancel_invite(client_b1.user_id().unwrap(), cx)
1268        })
1269        .await
1270        .unwrap();
1271    executor.run_until_parked();
1272    assert!(incoming_call_b1.next().await.unwrap().is_none());
1273    assert!(incoming_call_b2.next().await.unwrap().is_none());
1274
1275    // User A calls user B again.
1276    active_call_a
1277        .update(cx_a, |call, cx| {
1278            call.invite(client_b1.user_id().unwrap(), None, cx)
1279        })
1280        .await
1281        .unwrap();
1282    executor.run_until_parked();
1283    assert!(incoming_call_b1.next().await.unwrap().is_some());
1284    assert!(incoming_call_b2.next().await.unwrap().is_some());
1285
1286    // User A hangs up, causing both connections to stop ringing.
1287    active_call_a
1288        .update(cx_a, |call, cx| call.hang_up(cx))
1289        .await
1290        .unwrap();
1291    executor.run_until_parked();
1292    assert!(incoming_call_b1.next().await.unwrap().is_none());
1293    assert!(incoming_call_b2.next().await.unwrap().is_none());
1294
1295    // User A calls user B again.
1296    active_call_a
1297        .update(cx_a, |call, cx| {
1298            call.invite(client_b1.user_id().unwrap(), None, cx)
1299        })
1300        .await
1301        .unwrap();
1302    executor.run_until_parked();
1303    assert!(incoming_call_b1.next().await.unwrap().is_some());
1304    assert!(incoming_call_b2.next().await.unwrap().is_some());
1305
1306    // User A disconnects, causing both connections to stop ringing.
1307    server.forbid_connections();
1308    server.disconnect_client(client_a.peer_id().unwrap());
1309    executor.advance_clock(RECEIVE_TIMEOUT + RECONNECT_TIMEOUT);
1310    assert!(incoming_call_b1.next().await.unwrap().is_none());
1311    assert!(incoming_call_b2.next().await.unwrap().is_none());
1312
1313    // User A reconnects automatically, then calls user B again.
1314    server.allow_connections();
1315    executor.advance_clock(RECEIVE_TIMEOUT);
1316    active_call_a
1317        .update(cx_a, |call, cx| {
1318            call.invite(client_b1.user_id().unwrap(), None, cx)
1319        })
1320        .await
1321        .unwrap();
1322    executor.run_until_parked();
1323    assert!(incoming_call_b1.next().await.unwrap().is_some());
1324    assert!(incoming_call_b2.next().await.unwrap().is_some());
1325
1326    // User B disconnects all clients, causing user A to no longer see a pending call for them.
1327    server.forbid_connections();
1328    server.disconnect_client(client_b1.peer_id().unwrap());
1329    server.disconnect_client(client_b2.peer_id().unwrap());
1330    executor.advance_clock(RECEIVE_TIMEOUT + RECONNECT_TIMEOUT);
1331
1332    active_call_a.read_with(cx_a, |call, _| assert!(call.room().is_none()));
1333}
1334
1335#[gpui::test(iterations = 10)]
1336async fn test_unshare_project(
1337    executor: BackgroundExecutor,
1338    cx_a: &mut TestAppContext,
1339    cx_b: &mut TestAppContext,
1340    cx_c: &mut TestAppContext,
1341) {
1342    let mut server = TestServer::start(executor.clone()).await;
1343    let client_a = server.create_client(cx_a, "user_a").await;
1344    let client_b = server.create_client(cx_b, "user_b").await;
1345    let client_c = server.create_client(cx_c, "user_c").await;
1346    server
1347        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b), (&client_c, cx_c)])
1348        .await;
1349
1350    let active_call_a = cx_a.read(ActiveCall::global);
1351    let active_call_b = cx_b.read(ActiveCall::global);
1352
1353    client_a
1354        .fs()
1355        .insert_tree(
1356            "/a",
1357            json!({
1358                "a.txt": "a-contents",
1359                "b.txt": "b-contents",
1360            }),
1361        )
1362        .await;
1363
1364    let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
1365    let project_id = active_call_a
1366        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
1367        .await
1368        .unwrap();
1369
1370    let worktree_a = project_a.read_with(cx_a, |project, _| project.worktrees().next().unwrap());
1371    let project_b = client_b.build_remote_project(project_id, cx_b).await;
1372    executor.run_until_parked();
1373
1374    assert!(worktree_a.read_with(cx_a, |tree, _| tree.as_local().unwrap().is_shared()));
1375
1376    project_b
1377        .update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
1378        .await
1379        .unwrap();
1380
1381    // When client B leaves the room, the project becomes read-only.
1382    active_call_b
1383        .update(cx_b, |call, cx| call.hang_up(cx))
1384        .await
1385        .unwrap();
1386    executor.run_until_parked();
1387
1388    assert!(project_b.read_with(cx_b, |project, _| project.is_disconnected()));
1389
1390    // Client C opens the project.
1391    let project_c = client_c.build_remote_project(project_id, cx_c).await;
1392
1393    // When client A unshares the project, client C's project becomes read-only.
1394    project_a
1395        .update(cx_a, |project, cx| project.unshare(cx))
1396        .unwrap();
1397    executor.run_until_parked();
1398
1399    assert!(worktree_a.read_with(cx_a, |tree, _| !tree.as_local().unwrap().is_shared()));
1400
1401    assert!(project_c.read_with(cx_c, |project, _| project.is_disconnected()));
1402
1403    // Client C can open the project again after client A re-shares.
1404    let project_id = active_call_a
1405        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
1406        .await
1407        .unwrap();
1408    let project_c2 = client_c.build_remote_project(project_id, cx_c).await;
1409    executor.run_until_parked();
1410
1411    assert!(worktree_a.read_with(cx_a, |tree, _| tree.as_local().unwrap().is_shared()));
1412    project_c2
1413        .update(cx_c, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
1414        .await
1415        .unwrap();
1416
1417    // When client A (the host) leaves the room, the project gets unshared and guests are notified.
1418    active_call_a
1419        .update(cx_a, |call, cx| call.hang_up(cx))
1420        .await
1421        .unwrap();
1422    executor.run_until_parked();
1423
1424    project_a.read_with(cx_a, |project, _| assert!(!project.is_shared()));
1425
1426    project_c2.read_with(cx_c, |project, _| {
1427        assert!(project.is_disconnected());
1428        assert!(project.collaborators().is_empty());
1429    });
1430}
1431
1432#[gpui::test(iterations = 10)]
1433async fn test_project_reconnect(
1434    executor: BackgroundExecutor,
1435    cx_a: &mut TestAppContext,
1436    cx_b: &mut TestAppContext,
1437) {
1438    let mut server = TestServer::start(executor.clone()).await;
1439    let client_a = server.create_client(cx_a, "user_a").await;
1440    let client_b = server.create_client(cx_b, "user_b").await;
1441    server
1442        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
1443        .await;
1444
1445    cx_b.update(editor::init);
1446
1447    client_a
1448        .fs()
1449        .insert_tree(
1450            "/root-1",
1451            json!({
1452                "dir1": {
1453                    "a.txt": "a",
1454                    "b.txt": "b",
1455                    "subdir1": {
1456                        "c.txt": "c",
1457                        "d.txt": "d",
1458                        "e.txt": "e",
1459                    }
1460                },
1461                "dir2": {
1462                    "v.txt": "v",
1463                },
1464                "dir3": {
1465                    "w.txt": "w",
1466                    "x.txt": "x",
1467                    "y.txt": "y",
1468                },
1469                "dir4": {
1470                    "z.txt": "z",
1471                },
1472            }),
1473        )
1474        .await;
1475    client_a
1476        .fs()
1477        .insert_tree(
1478            "/root-2",
1479            json!({
1480                "2.txt": "2",
1481            }),
1482        )
1483        .await;
1484    client_a
1485        .fs()
1486        .insert_tree(
1487            "/root-3",
1488            json!({
1489                "3.txt": "3",
1490            }),
1491        )
1492        .await;
1493
1494    let active_call_a = cx_a.read(ActiveCall::global);
1495    let (project_a1, _) = client_a.build_local_project("/root-1/dir1", cx_a).await;
1496    let (project_a2, _) = client_a.build_local_project("/root-2", cx_a).await;
1497    let (project_a3, _) = client_a.build_local_project("/root-3", cx_a).await;
1498    let worktree_a1 = project_a1.read_with(cx_a, |project, _| project.worktrees().next().unwrap());
1499    let project1_id = active_call_a
1500        .update(cx_a, |call, cx| call.share_project(project_a1.clone(), cx))
1501        .await
1502        .unwrap();
1503    let project2_id = active_call_a
1504        .update(cx_a, |call, cx| call.share_project(project_a2.clone(), cx))
1505        .await
1506        .unwrap();
1507    let project3_id = active_call_a
1508        .update(cx_a, |call, cx| call.share_project(project_a3.clone(), cx))
1509        .await
1510        .unwrap();
1511
1512    let project_b1 = client_b.build_remote_project(project1_id, cx_b).await;
1513    let project_b2 = client_b.build_remote_project(project2_id, cx_b).await;
1514    let project_b3 = client_b.build_remote_project(project3_id, cx_b).await;
1515    executor.run_until_parked();
1516
1517    let worktree1_id = worktree_a1.read_with(cx_a, |worktree, _| {
1518        assert!(worktree.as_local().unwrap().is_shared());
1519        worktree.id()
1520    });
1521    let (worktree_a2, _) = project_a1
1522        .update(cx_a, |p, cx| {
1523            p.find_or_create_local_worktree("/root-1/dir2", true, cx)
1524        })
1525        .await
1526        .unwrap();
1527    executor.run_until_parked();
1528
1529    let worktree2_id = worktree_a2.read_with(cx_a, |tree, _| {
1530        assert!(tree.as_local().unwrap().is_shared());
1531        tree.id()
1532    });
1533    executor.run_until_parked();
1534
1535    project_b1.read_with(cx_b, |project, cx| {
1536        assert!(project.worktree_for_id(worktree2_id, cx).is_some())
1537    });
1538
1539    let buffer_a1 = project_a1
1540        .update(cx_a, |p, cx| p.open_buffer((worktree1_id, "a.txt"), cx))
1541        .await
1542        .unwrap();
1543    let buffer_b1 = project_b1
1544        .update(cx_b, |p, cx| p.open_buffer((worktree1_id, "a.txt"), cx))
1545        .await
1546        .unwrap();
1547
1548    // Drop client A's connection.
1549    server.forbid_connections();
1550    server.disconnect_client(client_a.peer_id().unwrap());
1551    executor.advance_clock(RECEIVE_TIMEOUT);
1552
1553    project_a1.read_with(cx_a, |project, _| {
1554        assert!(project.is_shared());
1555        assert_eq!(project.collaborators().len(), 1);
1556    });
1557
1558    project_b1.read_with(cx_b, |project, _| {
1559        assert!(!project.is_disconnected());
1560        assert_eq!(project.collaborators().len(), 1);
1561    });
1562
1563    worktree_a1.read_with(cx_a, |tree, _| {
1564        assert!(tree.as_local().unwrap().is_shared())
1565    });
1566
1567    // While client A is disconnected, add and remove files from client A's project.
1568    client_a
1569        .fs()
1570        .insert_tree(
1571            "/root-1/dir1/subdir2",
1572            json!({
1573                "f.txt": "f-contents",
1574                "g.txt": "g-contents",
1575                "h.txt": "h-contents",
1576                "i.txt": "i-contents",
1577            }),
1578        )
1579        .await;
1580    client_a
1581        .fs()
1582        .remove_dir(
1583            "/root-1/dir1/subdir1".as_ref(),
1584            RemoveOptions {
1585                recursive: true,
1586                ..Default::default()
1587            },
1588        )
1589        .await
1590        .unwrap();
1591
1592    // While client A is disconnected, add and remove worktrees from client A's project.
1593    project_a1.update(cx_a, |project, cx| {
1594        project.remove_worktree(worktree2_id, cx)
1595    });
1596    let (worktree_a3, _) = project_a1
1597        .update(cx_a, |p, cx| {
1598            p.find_or_create_local_worktree("/root-1/dir3", true, cx)
1599        })
1600        .await
1601        .unwrap();
1602    worktree_a3
1603        .read_with(cx_a, |tree, _| tree.as_local().unwrap().scan_complete())
1604        .await;
1605
1606    let worktree3_id = worktree_a3.read_with(cx_a, |tree, _| {
1607        assert!(!tree.as_local().unwrap().is_shared());
1608        tree.id()
1609    });
1610    executor.run_until_parked();
1611
1612    // While client A is disconnected, close project 2
1613    cx_a.update(|_| drop(project_a2));
1614
1615    // While client A is disconnected, mutate a buffer on both the host and the guest.
1616    buffer_a1.update(cx_a, |buf, cx| buf.edit([(0..0, "W")], None, cx));
1617    buffer_b1.update(cx_b, |buf, cx| buf.edit([(1..1, "Z")], None, cx));
1618    executor.run_until_parked();
1619
1620    // Client A reconnects. Their project is re-shared, and client B re-joins it.
1621    server.allow_connections();
1622    client_a
1623        .authenticate_and_connect(false, &cx_a.to_async())
1624        .await
1625        .unwrap();
1626    executor.run_until_parked();
1627
1628    project_a1.read_with(cx_a, |project, cx| {
1629        assert!(project.is_shared());
1630        assert!(worktree_a1.read(cx).as_local().unwrap().is_shared());
1631        assert_eq!(
1632            worktree_a1
1633                .read(cx)
1634                .snapshot()
1635                .paths()
1636                .map(|p| p.to_str().unwrap())
1637                .collect::<Vec<_>>(),
1638            vec![
1639                "a.txt",
1640                "b.txt",
1641                "subdir2",
1642                "subdir2/f.txt",
1643                "subdir2/g.txt",
1644                "subdir2/h.txt",
1645                "subdir2/i.txt"
1646            ]
1647        );
1648        assert!(worktree_a3.read(cx).as_local().unwrap().is_shared());
1649        assert_eq!(
1650            worktree_a3
1651                .read(cx)
1652                .snapshot()
1653                .paths()
1654                .map(|p| p.to_str().unwrap())
1655                .collect::<Vec<_>>(),
1656            vec!["w.txt", "x.txt", "y.txt"]
1657        );
1658    });
1659
1660    project_b1.read_with(cx_b, |project, cx| {
1661        assert!(!project.is_disconnected());
1662        assert_eq!(
1663            project
1664                .worktree_for_id(worktree1_id, cx)
1665                .unwrap()
1666                .read(cx)
1667                .snapshot()
1668                .paths()
1669                .map(|p| p.to_str().unwrap())
1670                .collect::<Vec<_>>(),
1671            vec![
1672                "a.txt",
1673                "b.txt",
1674                "subdir2",
1675                "subdir2/f.txt",
1676                "subdir2/g.txt",
1677                "subdir2/h.txt",
1678                "subdir2/i.txt"
1679            ]
1680        );
1681        assert!(project.worktree_for_id(worktree2_id, cx).is_none());
1682        assert_eq!(
1683            project
1684                .worktree_for_id(worktree3_id, cx)
1685                .unwrap()
1686                .read(cx)
1687                .snapshot()
1688                .paths()
1689                .map(|p| p.to_str().unwrap())
1690                .collect::<Vec<_>>(),
1691            vec!["w.txt", "x.txt", "y.txt"]
1692        );
1693    });
1694
1695    project_b2.read_with(cx_b, |project, _| assert!(project.is_disconnected()));
1696
1697    project_b3.read_with(cx_b, |project, _| assert!(!project.is_disconnected()));
1698
1699    buffer_a1.read_with(cx_a, |buffer, _| assert_eq!(buffer.text(), "WaZ"));
1700
1701    buffer_b1.read_with(cx_b, |buffer, _| assert_eq!(buffer.text(), "WaZ"));
1702
1703    // Drop client B's connection.
1704    server.forbid_connections();
1705    server.disconnect_client(client_b.peer_id().unwrap());
1706    executor.advance_clock(RECEIVE_TIMEOUT);
1707
1708    // While client B is disconnected, add and remove files from client A's project
1709    client_a
1710        .fs()
1711        .insert_file("/root-1/dir1/subdir2/j.txt", "j-contents".into())
1712        .await;
1713    client_a
1714        .fs()
1715        .remove_file("/root-1/dir1/subdir2/i.txt".as_ref(), Default::default())
1716        .await
1717        .unwrap();
1718
1719    // While client B is disconnected, add and remove worktrees from client A's project.
1720    let (worktree_a4, _) = project_a1
1721        .update(cx_a, |p, cx| {
1722            p.find_or_create_local_worktree("/root-1/dir4", true, cx)
1723        })
1724        .await
1725        .unwrap();
1726    executor.run_until_parked();
1727
1728    let worktree4_id = worktree_a4.read_with(cx_a, |tree, _| {
1729        assert!(tree.as_local().unwrap().is_shared());
1730        tree.id()
1731    });
1732    project_a1.update(cx_a, |project, cx| {
1733        project.remove_worktree(worktree3_id, cx)
1734    });
1735    executor.run_until_parked();
1736
1737    // While client B is disconnected, mutate a buffer on both the host and the guest.
1738    buffer_a1.update(cx_a, |buf, cx| buf.edit([(1..1, "X")], None, cx));
1739    buffer_b1.update(cx_b, |buf, cx| buf.edit([(2..2, "Y")], None, cx));
1740    executor.run_until_parked();
1741
1742    // While disconnected, close project 3
1743    cx_a.update(|_| drop(project_a3));
1744
1745    // Client B reconnects. They re-join the room and the remaining shared project.
1746    server.allow_connections();
1747    client_b
1748        .authenticate_and_connect(false, &cx_b.to_async())
1749        .await
1750        .unwrap();
1751    executor.run_until_parked();
1752
1753    project_b1.read_with(cx_b, |project, cx| {
1754        assert!(!project.is_disconnected());
1755        assert_eq!(
1756            project
1757                .worktree_for_id(worktree1_id, cx)
1758                .unwrap()
1759                .read(cx)
1760                .snapshot()
1761                .paths()
1762                .map(|p| p.to_str().unwrap())
1763                .collect::<Vec<_>>(),
1764            vec![
1765                "a.txt",
1766                "b.txt",
1767                "subdir2",
1768                "subdir2/f.txt",
1769                "subdir2/g.txt",
1770                "subdir2/h.txt",
1771                "subdir2/j.txt"
1772            ]
1773        );
1774        assert!(project.worktree_for_id(worktree2_id, cx).is_none());
1775        assert_eq!(
1776            project
1777                .worktree_for_id(worktree4_id, cx)
1778                .unwrap()
1779                .read(cx)
1780                .snapshot()
1781                .paths()
1782                .map(|p| p.to_str().unwrap())
1783                .collect::<Vec<_>>(),
1784            vec!["z.txt"]
1785        );
1786    });
1787
1788    project_b3.read_with(cx_b, |project, _| assert!(project.is_disconnected()));
1789
1790    buffer_a1.read_with(cx_a, |buffer, _| assert_eq!(buffer.text(), "WXaYZ"));
1791
1792    buffer_b1.read_with(cx_b, |buffer, _| assert_eq!(buffer.text(), "WXaYZ"));
1793}
1794
1795#[gpui::test(iterations = 10)]
1796async fn test_active_call_events(
1797    executor: BackgroundExecutor,
1798    cx_a: &mut TestAppContext,
1799    cx_b: &mut TestAppContext,
1800) {
1801    let mut server = TestServer::start(executor.clone()).await;
1802    let client_a = server.create_client(cx_a, "user_a").await;
1803    let client_b = server.create_client(cx_b, "user_b").await;
1804    client_a.fs().insert_tree("/a", json!({})).await;
1805    client_b.fs().insert_tree("/b", json!({})).await;
1806
1807    let (project_a, _) = client_a.build_local_project("/a", cx_a).await;
1808    let (project_b, _) = client_b.build_local_project("/b", cx_b).await;
1809
1810    server
1811        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
1812        .await;
1813    let active_call_a = cx_a.read(ActiveCall::global);
1814    let active_call_b = cx_b.read(ActiveCall::global);
1815
1816    let events_a = active_call_events(cx_a);
1817    let events_b = active_call_events(cx_b);
1818
1819    let project_a_id = active_call_a
1820        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
1821        .await
1822        .unwrap();
1823    executor.run_until_parked();
1824    assert_eq!(mem::take(&mut *events_a.borrow_mut()), vec![]);
1825    assert_eq!(
1826        mem::take(&mut *events_b.borrow_mut()),
1827        vec![room::Event::RemoteProjectShared {
1828            owner: Arc::new(User {
1829                id: client_a.user_id().unwrap(),
1830                github_login: "user_a".to_string(),
1831                avatar_uri: "avatar_a".into(),
1832            }),
1833            project_id: project_a_id,
1834            worktree_root_names: vec!["a".to_string()],
1835        }]
1836    );
1837
1838    let project_b_id = active_call_b
1839        .update(cx_b, |call, cx| call.share_project(project_b.clone(), cx))
1840        .await
1841        .unwrap();
1842    executor.run_until_parked();
1843    assert_eq!(
1844        mem::take(&mut *events_a.borrow_mut()),
1845        vec![room::Event::RemoteProjectShared {
1846            owner: Arc::new(User {
1847                id: client_b.user_id().unwrap(),
1848                github_login: "user_b".to_string(),
1849                avatar_uri: "avatar_b".into(),
1850            }),
1851            project_id: project_b_id,
1852            worktree_root_names: vec!["b".to_string()]
1853        }]
1854    );
1855    assert_eq!(mem::take(&mut *events_b.borrow_mut()), vec![]);
1856
1857    // Sharing a project twice is idempotent.
1858    let project_b_id_2 = active_call_b
1859        .update(cx_b, |call, cx| call.share_project(project_b.clone(), cx))
1860        .await
1861        .unwrap();
1862    assert_eq!(project_b_id_2, project_b_id);
1863    executor.run_until_parked();
1864    assert_eq!(mem::take(&mut *events_a.borrow_mut()), vec![]);
1865    assert_eq!(mem::take(&mut *events_b.borrow_mut()), vec![]);
1866}
1867
1868fn active_call_events(cx: &mut TestAppContext) -> Rc<RefCell<Vec<room::Event>>> {
1869    let events = Rc::new(RefCell::new(Vec::new()));
1870    let active_call = cx.read(ActiveCall::global);
1871    cx.update({
1872        let events = events.clone();
1873        |cx| {
1874            cx.subscribe(&active_call, move |_, event, _| {
1875                events.borrow_mut().push(event.clone())
1876            })
1877            .detach()
1878        }
1879    });
1880    events
1881}
1882
1883#[gpui::test]
1884async fn test_mute_deafen(
1885    executor: BackgroundExecutor,
1886    cx_a: &mut TestAppContext,
1887    cx_b: &mut TestAppContext,
1888    cx_c: &mut TestAppContext,
1889) {
1890    let mut server = TestServer::start(executor.clone()).await;
1891    let client_a = server.create_client(cx_a, "user_a").await;
1892    let client_b = server.create_client(cx_b, "user_b").await;
1893    let client_c = server.create_client(cx_c, "user_c").await;
1894
1895    server
1896        .make_contacts(&mut [(&client_a, cx_a), (&client_b, cx_b), (&client_c, cx_c)])
1897        .await;
1898
1899    let active_call_a = cx_a.read(ActiveCall::global);
1900    let active_call_b = cx_b.read(ActiveCall::global);
1901    let active_call_c = cx_c.read(ActiveCall::global);
1902
1903    // User A calls user B, B answers.
1904    active_call_a
1905        .update(cx_a, |call, cx| {
1906            call.invite(client_b.user_id().unwrap(), None, cx)
1907        })
1908        .await
1909        .unwrap();
1910    executor.run_until_parked();
1911    active_call_b
1912        .update(cx_b, |call, cx| call.accept_incoming(cx))
1913        .await
1914        .unwrap();
1915    executor.run_until_parked();
1916
1917    let room_a = active_call_a.read_with(cx_a, |call, _| call.room().unwrap().clone());
1918    let room_b = active_call_b.read_with(cx_b, |call, _| call.room().unwrap().clone());
1919
1920    room_a.read_with(cx_a, |room, _| assert!(!room.is_muted()));
1921    room_b.read_with(cx_b, |room, _| assert!(!room.is_muted()));
1922
1923    // Users A and B are both muted.
1924    assert_eq!(
1925        participant_audio_state(&room_a, cx_a),
1926        &[ParticipantAudioState {
1927            user_id: client_b.user_id().unwrap(),
1928            is_muted: false,
1929            audio_tracks_playing: vec![true],
1930        }]
1931    );
1932    assert_eq!(
1933        participant_audio_state(&room_b, cx_b),
1934        &[ParticipantAudioState {
1935            user_id: client_a.user_id().unwrap(),
1936            is_muted: false,
1937            audio_tracks_playing: vec![true],
1938        }]
1939    );
1940
1941    // User A mutes
1942    room_a.update(cx_a, |room, cx| room.toggle_mute(cx));
1943    executor.run_until_parked();
1944
1945    // User A hears user B, but B doesn't hear A.
1946    room_a.read_with(cx_a, |room, _| assert!(room.is_muted()));
1947    room_b.read_with(cx_b, |room, _| assert!(!room.is_muted()));
1948    assert_eq!(
1949        participant_audio_state(&room_a, cx_a),
1950        &[ParticipantAudioState {
1951            user_id: client_b.user_id().unwrap(),
1952            is_muted: false,
1953            audio_tracks_playing: vec![true],
1954        }]
1955    );
1956    assert_eq!(
1957        participant_audio_state(&room_b, cx_b),
1958        &[ParticipantAudioState {
1959            user_id: client_a.user_id().unwrap(),
1960            is_muted: true,
1961            audio_tracks_playing: vec![true],
1962        }]
1963    );
1964
1965    // User A deafens
1966    room_a.update(cx_a, |room, cx| room.toggle_deafen(cx));
1967    executor.run_until_parked();
1968
1969    // User A does not hear user B.
1970    room_a.read_with(cx_a, |room, _| assert!(room.is_muted()));
1971    room_b.read_with(cx_b, |room, _| assert!(!room.is_muted()));
1972    assert_eq!(
1973        participant_audio_state(&room_a, cx_a),
1974        &[ParticipantAudioState {
1975            user_id: client_b.user_id().unwrap(),
1976            is_muted: false,
1977            audio_tracks_playing: vec![false],
1978        }]
1979    );
1980    assert_eq!(
1981        participant_audio_state(&room_b, cx_b),
1982        &[ParticipantAudioState {
1983            user_id: client_a.user_id().unwrap(),
1984            is_muted: true,
1985            audio_tracks_playing: vec![true],
1986        }]
1987    );
1988
1989    // User B calls user C, C joins.
1990    active_call_b
1991        .update(cx_b, |call, cx| {
1992            call.invite(client_c.user_id().unwrap(), None, cx)
1993        })
1994        .await
1995        .unwrap();
1996    executor.run_until_parked();
1997    active_call_c
1998        .update(cx_c, |call, cx| call.accept_incoming(cx))
1999        .await
2000        .unwrap();
2001    executor.run_until_parked();
2002
2003    // User A does not hear users B or C.
2004    assert_eq!(
2005        participant_audio_state(&room_a, cx_a),
2006        &[
2007            ParticipantAudioState {
2008                user_id: client_b.user_id().unwrap(),
2009                is_muted: false,
2010                audio_tracks_playing: vec![false],
2011            },
2012            ParticipantAudioState {
2013                user_id: client_c.user_id().unwrap(),
2014                is_muted: false,
2015                audio_tracks_playing: vec![false],
2016            }
2017        ]
2018    );
2019    assert_eq!(
2020        participant_audio_state(&room_b, cx_b),
2021        &[
2022            ParticipantAudioState {
2023                user_id: client_a.user_id().unwrap(),
2024                is_muted: true,
2025                audio_tracks_playing: vec![true],
2026            },
2027            ParticipantAudioState {
2028                user_id: client_c.user_id().unwrap(),
2029                is_muted: false,
2030                audio_tracks_playing: vec![true],
2031            }
2032        ]
2033    );
2034
2035    #[derive(PartialEq, Eq, Debug)]
2036    struct ParticipantAudioState {
2037        user_id: u64,
2038        is_muted: bool,
2039        audio_tracks_playing: Vec<bool>,
2040    }
2041
2042    fn participant_audio_state(
2043        room: &Model<Room>,
2044        cx: &TestAppContext,
2045    ) -> Vec<ParticipantAudioState> {
2046        room.read_with(cx, |room, _| {
2047            room.remote_participants()
2048                .iter()
2049                .map(|(user_id, participant)| ParticipantAudioState {
2050                    user_id: *user_id,
2051                    is_muted: participant.muted,
2052                    audio_tracks_playing: participant
2053                        .audio_tracks
2054                        .values()
2055                        .map(|track| track.is_playing())
2056                        .collect(),
2057                })
2058                .collect::<Vec<_>>()
2059        })
2060    }
2061}
2062
2063#[gpui::test(iterations = 10)]
2064async fn test_room_location(
2065    executor: BackgroundExecutor,
2066    cx_a: &mut TestAppContext,
2067    cx_b: &mut TestAppContext,
2068) {
2069    let mut server = TestServer::start(executor.clone()).await;
2070    let client_a = server.create_client(cx_a, "user_a").await;
2071    let client_b = server.create_client(cx_b, "user_b").await;
2072    client_a.fs().insert_tree("/a", json!({})).await;
2073    client_b.fs().insert_tree("/b", json!({})).await;
2074
2075    let active_call_a = cx_a.read(ActiveCall::global);
2076    let active_call_b = cx_b.read(ActiveCall::global);
2077
2078    let a_notified = Rc::new(Cell::new(false));
2079    cx_a.update({
2080        let notified = a_notified.clone();
2081        |cx| {
2082            cx.observe(&active_call_a, move |_, _| notified.set(true))
2083                .detach()
2084        }
2085    });
2086
2087    let b_notified = Rc::new(Cell::new(false));
2088    cx_b.update({
2089        let b_notified = b_notified.clone();
2090        |cx| {
2091            cx.observe(&active_call_b, move |_, _| b_notified.set(true))
2092                .detach()
2093        }
2094    });
2095
2096    let (project_a, _) = client_a.build_local_project("/a", cx_a).await;
2097    active_call_a
2098        .update(cx_a, |call, cx| call.set_location(Some(&project_a), cx))
2099        .await
2100        .unwrap();
2101    let (project_b, _) = client_b.build_local_project("/b", cx_b).await;
2102
2103    server
2104        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
2105        .await;
2106
2107    let room_a = active_call_a.read_with(cx_a, |call, _| call.room().unwrap().clone());
2108
2109    let room_b = active_call_b.read_with(cx_b, |call, _| call.room().unwrap().clone());
2110    executor.run_until_parked();
2111    assert!(a_notified.take());
2112    assert_eq!(
2113        participant_locations(&room_a, cx_a),
2114        vec![("user_b".to_string(), ParticipantLocation::External)]
2115    );
2116    assert!(b_notified.take());
2117    assert_eq!(
2118        participant_locations(&room_b, cx_b),
2119        vec![("user_a".to_string(), ParticipantLocation::UnsharedProject)]
2120    );
2121
2122    let project_a_id = active_call_a
2123        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
2124        .await
2125        .unwrap();
2126    executor.run_until_parked();
2127    assert!(a_notified.take());
2128    assert_eq!(
2129        participant_locations(&room_a, cx_a),
2130        vec![("user_b".to_string(), ParticipantLocation::External)]
2131    );
2132    assert!(b_notified.take());
2133    assert_eq!(
2134        participant_locations(&room_b, cx_b),
2135        vec![(
2136            "user_a".to_string(),
2137            ParticipantLocation::SharedProject {
2138                project_id: project_a_id
2139            }
2140        )]
2141    );
2142
2143    let project_b_id = active_call_b
2144        .update(cx_b, |call, cx| call.share_project(project_b.clone(), cx))
2145        .await
2146        .unwrap();
2147    executor.run_until_parked();
2148    assert!(a_notified.take());
2149    assert_eq!(
2150        participant_locations(&room_a, cx_a),
2151        vec![("user_b".to_string(), ParticipantLocation::External)]
2152    );
2153    assert!(b_notified.take());
2154    assert_eq!(
2155        participant_locations(&room_b, cx_b),
2156        vec![(
2157            "user_a".to_string(),
2158            ParticipantLocation::SharedProject {
2159                project_id: project_a_id
2160            }
2161        )]
2162    );
2163
2164    active_call_b
2165        .update(cx_b, |call, cx| call.set_location(Some(&project_b), cx))
2166        .await
2167        .unwrap();
2168    executor.run_until_parked();
2169    assert!(a_notified.take());
2170    assert_eq!(
2171        participant_locations(&room_a, cx_a),
2172        vec![(
2173            "user_b".to_string(),
2174            ParticipantLocation::SharedProject {
2175                project_id: project_b_id
2176            }
2177        )]
2178    );
2179    assert!(b_notified.take());
2180    assert_eq!(
2181        participant_locations(&room_b, cx_b),
2182        vec![(
2183            "user_a".to_string(),
2184            ParticipantLocation::SharedProject {
2185                project_id: project_a_id
2186            }
2187        )]
2188    );
2189
2190    active_call_b
2191        .update(cx_b, |call, cx| call.set_location(None, cx))
2192        .await
2193        .unwrap();
2194    executor.run_until_parked();
2195    assert!(a_notified.take());
2196    assert_eq!(
2197        participant_locations(&room_a, cx_a),
2198        vec![("user_b".to_string(), ParticipantLocation::External)]
2199    );
2200    assert!(b_notified.take());
2201    assert_eq!(
2202        participant_locations(&room_b, cx_b),
2203        vec![(
2204            "user_a".to_string(),
2205            ParticipantLocation::SharedProject {
2206                project_id: project_a_id
2207            }
2208        )]
2209    );
2210
2211    fn participant_locations(
2212        room: &Model<Room>,
2213        cx: &TestAppContext,
2214    ) -> Vec<(String, ParticipantLocation)> {
2215        room.read_with(cx, |room, _| {
2216            room.remote_participants()
2217                .values()
2218                .map(|participant| {
2219                    (
2220                        participant.user.github_login.to_string(),
2221                        participant.location,
2222                    )
2223                })
2224                .collect()
2225        })
2226    }
2227}
2228
2229#[gpui::test(iterations = 10)]
2230async fn test_propagate_saves_and_fs_changes(
2231    executor: BackgroundExecutor,
2232    cx_a: &mut TestAppContext,
2233    cx_b: &mut TestAppContext,
2234    cx_c: &mut TestAppContext,
2235) {
2236    let mut server = TestServer::start(executor.clone()).await;
2237    let client_a = server.create_client(cx_a, "user_a").await;
2238    let client_b = server.create_client(cx_b, "user_b").await;
2239    let client_c = server.create_client(cx_c, "user_c").await;
2240
2241    server
2242        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b), (&client_c, cx_c)])
2243        .await;
2244    let active_call_a = cx_a.read(ActiveCall::global);
2245
2246    let rust = Arc::new(Language::new(
2247        LanguageConfig {
2248            name: "Rust".into(),
2249            path_suffixes: vec!["rs".to_string()],
2250            ..Default::default()
2251        },
2252        Some(tree_sitter_rust::language()),
2253    ));
2254    let javascript = Arc::new(Language::new(
2255        LanguageConfig {
2256            name: "JavaScript".into(),
2257            path_suffixes: vec!["js".to_string()],
2258            ..Default::default()
2259        },
2260        Some(tree_sitter_rust::language()),
2261    ));
2262    for client in [&client_a, &client_b, &client_c] {
2263        client.language_registry().add(rust.clone());
2264        client.language_registry().add(javascript.clone());
2265    }
2266
2267    client_a
2268        .fs()
2269        .insert_tree(
2270            "/a",
2271            json!({
2272                "file1.rs": "",
2273                "file2": ""
2274            }),
2275        )
2276        .await;
2277    let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
2278
2279    let worktree_a = project_a.read_with(cx_a, |p, _| p.worktrees().next().unwrap());
2280    let project_id = active_call_a
2281        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
2282        .await
2283        .unwrap();
2284
2285    // Join that worktree as clients B and C.
2286    let project_b = client_b.build_remote_project(project_id, cx_b).await;
2287    let project_c = client_c.build_remote_project(project_id, cx_c).await;
2288
2289    let worktree_b = project_b.read_with(cx_b, |p, _| p.worktrees().next().unwrap());
2290
2291    let worktree_c = project_c.read_with(cx_c, |p, _| p.worktrees().next().unwrap());
2292
2293    // Open and edit a buffer as both guests B and C.
2294    let buffer_b = project_b
2295        .update(cx_b, |p, cx| p.open_buffer((worktree_id, "file1.rs"), cx))
2296        .await
2297        .unwrap();
2298    let buffer_c = project_c
2299        .update(cx_c, |p, cx| p.open_buffer((worktree_id, "file1.rs"), cx))
2300        .await
2301        .unwrap();
2302
2303    buffer_b.read_with(cx_b, |buffer, _| {
2304        assert_eq!(&*buffer.language().unwrap().name(), "Rust");
2305    });
2306
2307    buffer_c.read_with(cx_c, |buffer, _| {
2308        assert_eq!(&*buffer.language().unwrap().name(), "Rust");
2309    });
2310    buffer_b.update(cx_b, |buf, cx| buf.edit([(0..0, "i-am-b, ")], None, cx));
2311    buffer_c.update(cx_c, |buf, cx| buf.edit([(0..0, "i-am-c, ")], None, cx));
2312
2313    // Open and edit that buffer as the host.
2314    let buffer_a = project_a
2315        .update(cx_a, |p, cx| p.open_buffer((worktree_id, "file1.rs"), cx))
2316        .await
2317        .unwrap();
2318
2319    executor.run_until_parked();
2320
2321    buffer_a.read_with(cx_a, |buf, _| assert_eq!(buf.text(), "i-am-c, i-am-b, "));
2322    buffer_a.update(cx_a, |buf, cx| {
2323        buf.edit([(buf.len()..buf.len(), "i-am-a")], None, cx)
2324    });
2325
2326    executor.run_until_parked();
2327
2328    buffer_a.read_with(cx_a, |buf, _| {
2329        assert_eq!(buf.text(), "i-am-c, i-am-b, i-am-a");
2330    });
2331
2332    buffer_b.read_with(cx_b, |buf, _| {
2333        assert_eq!(buf.text(), "i-am-c, i-am-b, i-am-a");
2334    });
2335
2336    buffer_c.read_with(cx_c, |buf, _| {
2337        assert_eq!(buf.text(), "i-am-c, i-am-b, i-am-a");
2338    });
2339
2340    // Edit the buffer as the host and concurrently save as guest B.
2341    let save_b = project_b.update(cx_b, |project, cx| {
2342        project.save_buffer(buffer_b.clone(), cx)
2343    });
2344    buffer_a.update(cx_a, |buf, cx| buf.edit([(0..0, "hi-a, ")], None, cx));
2345    save_b.await.unwrap();
2346    assert_eq!(
2347        client_a.fs().load("/a/file1.rs".as_ref()).await.unwrap(),
2348        "hi-a, i-am-c, i-am-b, i-am-a"
2349    );
2350
2351    executor.run_until_parked();
2352
2353    buffer_a.read_with(cx_a, |buf, _| assert!(!buf.is_dirty()));
2354
2355    buffer_b.read_with(cx_b, |buf, _| assert!(!buf.is_dirty()));
2356
2357    buffer_c.read_with(cx_c, |buf, _| assert!(!buf.is_dirty()));
2358
2359    // Make changes on host's file system, see those changes on guest worktrees.
2360    client_a
2361        .fs()
2362        .rename(
2363            "/a/file1.rs".as_ref(),
2364            "/a/file1.js".as_ref(),
2365            Default::default(),
2366        )
2367        .await
2368        .unwrap();
2369    client_a
2370        .fs()
2371        .rename("/a/file2".as_ref(), "/a/file3".as_ref(), Default::default())
2372        .await
2373        .unwrap();
2374    client_a.fs().insert_file("/a/file4", "4".into()).await;
2375    executor.run_until_parked();
2376
2377    worktree_a.read_with(cx_a, |tree, _| {
2378        assert_eq!(
2379            tree.paths()
2380                .map(|p| p.to_string_lossy())
2381                .collect::<Vec<_>>(),
2382            ["file1.js", "file3", "file4"]
2383        )
2384    });
2385
2386    worktree_b.read_with(cx_b, |tree, _| {
2387        assert_eq!(
2388            tree.paths()
2389                .map(|p| p.to_string_lossy())
2390                .collect::<Vec<_>>(),
2391            ["file1.js", "file3", "file4"]
2392        )
2393    });
2394
2395    worktree_c.read_with(cx_c, |tree, _| {
2396        assert_eq!(
2397            tree.paths()
2398                .map(|p| p.to_string_lossy())
2399                .collect::<Vec<_>>(),
2400            ["file1.js", "file3", "file4"]
2401        )
2402    });
2403
2404    // Ensure buffer files are updated as well.
2405
2406    buffer_a.read_with(cx_a, |buffer, _| {
2407        assert_eq!(buffer.file().unwrap().path().to_str(), Some("file1.js"));
2408        assert_eq!(&*buffer.language().unwrap().name(), "JavaScript");
2409    });
2410
2411    buffer_b.read_with(cx_b, |buffer, _| {
2412        assert_eq!(buffer.file().unwrap().path().to_str(), Some("file1.js"));
2413        assert_eq!(&*buffer.language().unwrap().name(), "JavaScript");
2414    });
2415
2416    buffer_c.read_with(cx_c, |buffer, _| {
2417        assert_eq!(buffer.file().unwrap().path().to_str(), Some("file1.js"));
2418        assert_eq!(&*buffer.language().unwrap().name(), "JavaScript");
2419    });
2420
2421    let new_buffer_a = project_a
2422        .update(cx_a, |p, cx| p.create_buffer("", None, cx))
2423        .unwrap();
2424
2425    let new_buffer_id = new_buffer_a.read_with(cx_a, |buffer, _| buffer.remote_id());
2426    let new_buffer_b = project_b
2427        .update(cx_b, |p, cx| p.open_buffer_by_id(new_buffer_id, cx))
2428        .await
2429        .unwrap();
2430
2431    new_buffer_b.read_with(cx_b, |buffer, _| {
2432        assert!(buffer.file().is_none());
2433    });
2434
2435    new_buffer_a.update(cx_a, |buffer, cx| {
2436        buffer.edit([(0..0, "ok")], None, cx);
2437    });
2438    project_a
2439        .update(cx_a, |project, cx| {
2440            project.save_buffer_as(new_buffer_a.clone(), "/a/file3.rs".into(), cx)
2441        })
2442        .await
2443        .unwrap();
2444
2445    executor.run_until_parked();
2446
2447    new_buffer_b.read_with(cx_b, |buffer_b, _| {
2448        assert_eq!(
2449            buffer_b.file().unwrap().path().as_ref(),
2450            Path::new("file3.rs")
2451        );
2452
2453        new_buffer_a.read_with(cx_a, |buffer_a, _| {
2454            assert_eq!(buffer_b.saved_mtime(), buffer_a.saved_mtime());
2455            assert_eq!(buffer_b.saved_version(), buffer_a.saved_version());
2456        });
2457    });
2458}
2459
2460#[gpui::test(iterations = 10)]
2461async fn test_git_diff_base_change(
2462    executor: BackgroundExecutor,
2463    cx_a: &mut TestAppContext,
2464    cx_b: &mut TestAppContext,
2465) {
2466    let mut server = TestServer::start(executor.clone()).await;
2467    let client_a = server.create_client(cx_a, "user_a").await;
2468    let client_b = server.create_client(cx_b, "user_b").await;
2469    server
2470        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
2471        .await;
2472    let active_call_a = cx_a.read(ActiveCall::global);
2473
2474    client_a
2475        .fs()
2476        .insert_tree(
2477            "/dir",
2478            json!({
2479            ".git": {},
2480            "sub": {
2481                ".git": {},
2482                "b.txt": "
2483                    one
2484                    two
2485                    three
2486                ".unindent(),
2487            },
2488            "a.txt": "
2489                    one
2490                    two
2491                    three
2492                ".unindent(),
2493            }),
2494        )
2495        .await;
2496
2497    let (project_local, worktree_id) = client_a.build_local_project("/dir", cx_a).await;
2498    let project_id = active_call_a
2499        .update(cx_a, |call, cx| {
2500            call.share_project(project_local.clone(), cx)
2501        })
2502        .await
2503        .unwrap();
2504
2505    let project_remote = client_b.build_remote_project(project_id, cx_b).await;
2506
2507    let diff_base = "
2508        one
2509        three
2510    "
2511    .unindent();
2512
2513    let new_diff_base = "
2514        one
2515        two
2516    "
2517    .unindent();
2518
2519    client_a.fs().set_index_for_repo(
2520        Path::new("/dir/.git"),
2521        &[(Path::new("a.txt"), diff_base.clone())],
2522    );
2523
2524    // Create the buffer
2525    let buffer_local_a = project_local
2526        .update(cx_a, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
2527        .await
2528        .unwrap();
2529
2530    // Wait for it to catch up to the new diff
2531    executor.run_until_parked();
2532
2533    // Smoke test diffing
2534
2535    buffer_local_a.read_with(cx_a, |buffer, _| {
2536        assert_eq!(buffer.diff_base(), Some(diff_base.as_ref()));
2537        git::diff::assert_hunks(
2538            buffer.snapshot().git_diff_hunks_in_row_range(0..4),
2539            &buffer,
2540            &diff_base,
2541            &[(1..2, "", "two\n")],
2542        );
2543    });
2544
2545    // Create remote buffer
2546    let buffer_remote_a = project_remote
2547        .update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
2548        .await
2549        .unwrap();
2550
2551    // Wait remote buffer to catch up to the new diff
2552    executor.run_until_parked();
2553
2554    // Smoke test diffing
2555
2556    buffer_remote_a.read_with(cx_b, |buffer, _| {
2557        assert_eq!(buffer.diff_base(), Some(diff_base.as_ref()));
2558        git::diff::assert_hunks(
2559            buffer.snapshot().git_diff_hunks_in_row_range(0..4),
2560            &buffer,
2561            &diff_base,
2562            &[(1..2, "", "two\n")],
2563        );
2564    });
2565
2566    client_a.fs().set_index_for_repo(
2567        Path::new("/dir/.git"),
2568        &[(Path::new("a.txt"), new_diff_base.clone())],
2569    );
2570
2571    // Wait for buffer_local_a to receive it
2572    executor.run_until_parked();
2573
2574    // Smoke test new diffing
2575
2576    buffer_local_a.read_with(cx_a, |buffer, _| {
2577        assert_eq!(buffer.diff_base(), Some(new_diff_base.as_ref()));
2578
2579        git::diff::assert_hunks(
2580            buffer.snapshot().git_diff_hunks_in_row_range(0..4),
2581            &buffer,
2582            &diff_base,
2583            &[(2..3, "", "three\n")],
2584        );
2585    });
2586
2587    // Smoke test B
2588
2589    buffer_remote_a.read_with(cx_b, |buffer, _| {
2590        assert_eq!(buffer.diff_base(), Some(new_diff_base.as_ref()));
2591        git::diff::assert_hunks(
2592            buffer.snapshot().git_diff_hunks_in_row_range(0..4),
2593            &buffer,
2594            &diff_base,
2595            &[(2..3, "", "three\n")],
2596        );
2597    });
2598
2599    //Nested git dir
2600
2601    let diff_base = "
2602        one
2603        three
2604    "
2605    .unindent();
2606
2607    let new_diff_base = "
2608        one
2609        two
2610    "
2611    .unindent();
2612
2613    client_a.fs().set_index_for_repo(
2614        Path::new("/dir/sub/.git"),
2615        &[(Path::new("b.txt"), diff_base.clone())],
2616    );
2617
2618    // Create the buffer
2619    let buffer_local_b = project_local
2620        .update(cx_a, |p, cx| p.open_buffer((worktree_id, "sub/b.txt"), cx))
2621        .await
2622        .unwrap();
2623
2624    // Wait for it to catch up to the new diff
2625    executor.run_until_parked();
2626
2627    // Smoke test diffing
2628
2629    buffer_local_b.read_with(cx_a, |buffer, _| {
2630        assert_eq!(buffer.diff_base(), Some(diff_base.as_ref()));
2631        git::diff::assert_hunks(
2632            buffer.snapshot().git_diff_hunks_in_row_range(0..4),
2633            &buffer,
2634            &diff_base,
2635            &[(1..2, "", "two\n")],
2636        );
2637    });
2638
2639    // Create remote buffer
2640    let buffer_remote_b = project_remote
2641        .update(cx_b, |p, cx| p.open_buffer((worktree_id, "sub/b.txt"), cx))
2642        .await
2643        .unwrap();
2644
2645    // Wait remote buffer to catch up to the new diff
2646    executor.run_until_parked();
2647
2648    // Smoke test diffing
2649
2650    buffer_remote_b.read_with(cx_b, |buffer, _| {
2651        assert_eq!(buffer.diff_base(), Some(diff_base.as_ref()));
2652        git::diff::assert_hunks(
2653            buffer.snapshot().git_diff_hunks_in_row_range(0..4),
2654            &buffer,
2655            &diff_base,
2656            &[(1..2, "", "two\n")],
2657        );
2658    });
2659
2660    client_a.fs().set_index_for_repo(
2661        Path::new("/dir/sub/.git"),
2662        &[(Path::new("b.txt"), new_diff_base.clone())],
2663    );
2664
2665    // Wait for buffer_local_b to receive it
2666    executor.run_until_parked();
2667
2668    // Smoke test new diffing
2669
2670    buffer_local_b.read_with(cx_a, |buffer, _| {
2671        assert_eq!(buffer.diff_base(), Some(new_diff_base.as_ref()));
2672        println!("{:?}", buffer.as_rope().to_string());
2673        println!("{:?}", buffer.diff_base());
2674        println!(
2675            "{:?}",
2676            buffer
2677                .snapshot()
2678                .git_diff_hunks_in_row_range(0..4)
2679                .collect::<Vec<_>>()
2680        );
2681
2682        git::diff::assert_hunks(
2683            buffer.snapshot().git_diff_hunks_in_row_range(0..4),
2684            &buffer,
2685            &diff_base,
2686            &[(2..3, "", "three\n")],
2687        );
2688    });
2689
2690    // Smoke test B
2691
2692    buffer_remote_b.read_with(cx_b, |buffer, _| {
2693        assert_eq!(buffer.diff_base(), Some(new_diff_base.as_ref()));
2694        git::diff::assert_hunks(
2695            buffer.snapshot().git_diff_hunks_in_row_range(0..4),
2696            &buffer,
2697            &diff_base,
2698            &[(2..3, "", "three\n")],
2699        );
2700    });
2701}
2702
2703#[gpui::test]
2704async fn test_git_branch_name(
2705    executor: BackgroundExecutor,
2706    cx_a: &mut TestAppContext,
2707    cx_b: &mut TestAppContext,
2708    cx_c: &mut TestAppContext,
2709) {
2710    let mut server = TestServer::start(executor.clone()).await;
2711    let client_a = server.create_client(cx_a, "user_a").await;
2712    let client_b = server.create_client(cx_b, "user_b").await;
2713    let client_c = server.create_client(cx_c, "user_c").await;
2714    server
2715        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b), (&client_c, cx_c)])
2716        .await;
2717    let active_call_a = cx_a.read(ActiveCall::global);
2718
2719    client_a
2720        .fs()
2721        .insert_tree(
2722            "/dir",
2723            json!({
2724            ".git": {},
2725            }),
2726        )
2727        .await;
2728
2729    let (project_local, _worktree_id) = client_a.build_local_project("/dir", cx_a).await;
2730    let project_id = active_call_a
2731        .update(cx_a, |call, cx| {
2732            call.share_project(project_local.clone(), cx)
2733        })
2734        .await
2735        .unwrap();
2736
2737    let project_remote = client_b.build_remote_project(project_id, cx_b).await;
2738    client_a
2739        .fs()
2740        .set_branch_name(Path::new("/dir/.git"), Some("branch-1"));
2741
2742    // Wait for it to catch up to the new branch
2743    executor.run_until_parked();
2744
2745    #[track_caller]
2746    fn assert_branch(branch_name: Option<impl Into<String>>, project: &Project, cx: &AppContext) {
2747        let branch_name = branch_name.map(Into::into);
2748        let worktrees = project.visible_worktrees(cx).collect::<Vec<_>>();
2749        assert_eq!(worktrees.len(), 1);
2750        let worktree = worktrees[0].clone();
2751        let root_entry = worktree.read(cx).snapshot().root_git_entry().unwrap();
2752        assert_eq!(root_entry.branch(), branch_name.map(Into::into));
2753    }
2754
2755    // Smoke test branch reading
2756
2757    project_local.read_with(cx_a, |project, cx| {
2758        assert_branch(Some("branch-1"), project, cx)
2759    });
2760
2761    project_remote.read_with(cx_b, |project, cx| {
2762        assert_branch(Some("branch-1"), project, cx)
2763    });
2764
2765    client_a
2766        .fs()
2767        .set_branch_name(Path::new("/dir/.git"), Some("branch-2"));
2768
2769    // Wait for buffer_local_a to receive it
2770    executor.run_until_parked();
2771
2772    // Smoke test branch reading
2773
2774    project_local.read_with(cx_a, |project, cx| {
2775        assert_branch(Some("branch-2"), project, cx)
2776    });
2777
2778    project_remote.read_with(cx_b, |project, cx| {
2779        assert_branch(Some("branch-2"), project, cx)
2780    });
2781
2782    let project_remote_c = client_c.build_remote_project(project_id, cx_c).await;
2783    executor.run_until_parked();
2784
2785    project_remote_c.read_with(cx_c, |project, cx| {
2786        assert_branch(Some("branch-2"), project, cx)
2787    });
2788}
2789
2790#[gpui::test]
2791async fn test_git_status_sync(
2792    executor: BackgroundExecutor,
2793    cx_a: &mut TestAppContext,
2794    cx_b: &mut TestAppContext,
2795    cx_c: &mut TestAppContext,
2796) {
2797    let mut server = TestServer::start(executor.clone()).await;
2798    let client_a = server.create_client(cx_a, "user_a").await;
2799    let client_b = server.create_client(cx_b, "user_b").await;
2800    let client_c = server.create_client(cx_c, "user_c").await;
2801    server
2802        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b), (&client_c, cx_c)])
2803        .await;
2804    let active_call_a = cx_a.read(ActiveCall::global);
2805
2806    client_a
2807        .fs()
2808        .insert_tree(
2809            "/dir",
2810            json!({
2811            ".git": {},
2812            "a.txt": "a",
2813            "b.txt": "b",
2814            }),
2815        )
2816        .await;
2817
2818    const A_TXT: &'static str = "a.txt";
2819    const B_TXT: &'static str = "b.txt";
2820
2821    client_a.fs().set_status_for_repo_via_git_operation(
2822        Path::new("/dir/.git"),
2823        &[
2824            (&Path::new(A_TXT), GitFileStatus::Added),
2825            (&Path::new(B_TXT), GitFileStatus::Added),
2826        ],
2827    );
2828
2829    let (project_local, _worktree_id) = client_a.build_local_project("/dir", cx_a).await;
2830    let project_id = active_call_a
2831        .update(cx_a, |call, cx| {
2832            call.share_project(project_local.clone(), cx)
2833        })
2834        .await
2835        .unwrap();
2836
2837    let project_remote = client_b.build_remote_project(project_id, cx_b).await;
2838
2839    // Wait for it to catch up to the new status
2840    executor.run_until_parked();
2841
2842    #[track_caller]
2843    fn assert_status(
2844        file: &impl AsRef<Path>,
2845        status: Option<GitFileStatus>,
2846        project: &Project,
2847        cx: &AppContext,
2848    ) {
2849        let file = file.as_ref();
2850        let worktrees = project.visible_worktrees(cx).collect::<Vec<_>>();
2851        assert_eq!(worktrees.len(), 1);
2852        let worktree = worktrees[0].clone();
2853        let snapshot = worktree.read(cx).snapshot();
2854        assert_eq!(snapshot.status_for_file(file), status);
2855    }
2856
2857    // Smoke test status reading
2858
2859    project_local.read_with(cx_a, |project, cx| {
2860        assert_status(&Path::new(A_TXT), Some(GitFileStatus::Added), project, cx);
2861        assert_status(&Path::new(B_TXT), Some(GitFileStatus::Added), project, cx);
2862    });
2863
2864    project_remote.read_with(cx_b, |project, cx| {
2865        assert_status(&Path::new(A_TXT), Some(GitFileStatus::Added), project, cx);
2866        assert_status(&Path::new(B_TXT), Some(GitFileStatus::Added), project, cx);
2867    });
2868
2869    client_a.fs().set_status_for_repo_via_working_copy_change(
2870        Path::new("/dir/.git"),
2871        &[
2872            (&Path::new(A_TXT), GitFileStatus::Modified),
2873            (&Path::new(B_TXT), GitFileStatus::Modified),
2874        ],
2875    );
2876
2877    // Wait for buffer_local_a to receive it
2878    executor.run_until_parked();
2879
2880    // Smoke test status reading
2881
2882    project_local.read_with(cx_a, |project, cx| {
2883        assert_status(
2884            &Path::new(A_TXT),
2885            Some(GitFileStatus::Modified),
2886            project,
2887            cx,
2888        );
2889        assert_status(
2890            &Path::new(B_TXT),
2891            Some(GitFileStatus::Modified),
2892            project,
2893            cx,
2894        );
2895    });
2896
2897    project_remote.read_with(cx_b, |project, cx| {
2898        assert_status(
2899            &Path::new(A_TXT),
2900            Some(GitFileStatus::Modified),
2901            project,
2902            cx,
2903        );
2904        assert_status(
2905            &Path::new(B_TXT),
2906            Some(GitFileStatus::Modified),
2907            project,
2908            cx,
2909        );
2910    });
2911
2912    // And synchronization while joining
2913    let project_remote_c = client_c.build_remote_project(project_id, cx_c).await;
2914    executor.run_until_parked();
2915
2916    project_remote_c.read_with(cx_c, |project, cx| {
2917        assert_status(
2918            &Path::new(A_TXT),
2919            Some(GitFileStatus::Modified),
2920            project,
2921            cx,
2922        );
2923        assert_status(
2924            &Path::new(B_TXT),
2925            Some(GitFileStatus::Modified),
2926            project,
2927            cx,
2928        );
2929    });
2930}
2931
2932#[gpui::test(iterations = 10)]
2933async fn test_fs_operations(
2934    executor: BackgroundExecutor,
2935    cx_a: &mut TestAppContext,
2936    cx_b: &mut TestAppContext,
2937) {
2938    let mut server = TestServer::start(executor.clone()).await;
2939    let client_a = server.create_client(cx_a, "user_a").await;
2940    let client_b = server.create_client(cx_b, "user_b").await;
2941    server
2942        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
2943        .await;
2944    let active_call_a = cx_a.read(ActiveCall::global);
2945
2946    client_a
2947        .fs()
2948        .insert_tree(
2949            "/dir",
2950            json!({
2951                "a.txt": "a-contents",
2952                "b.txt": "b-contents",
2953            }),
2954        )
2955        .await;
2956    let (project_a, worktree_id) = client_a.build_local_project("/dir", cx_a).await;
2957    let project_id = active_call_a
2958        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
2959        .await
2960        .unwrap();
2961    let project_b = client_b.build_remote_project(project_id, cx_b).await;
2962
2963    let worktree_a = project_a.read_with(cx_a, |project, _| project.worktrees().next().unwrap());
2964
2965    let worktree_b = project_b.read_with(cx_b, |project, _| project.worktrees().next().unwrap());
2966
2967    let entry = project_b
2968        .update(cx_b, |project, cx| {
2969            project.create_entry((worktree_id, "c.txt"), false, cx)
2970        })
2971        .await
2972        .unwrap()
2973        .unwrap();
2974
2975    worktree_a.read_with(cx_a, |worktree, _| {
2976        assert_eq!(
2977            worktree
2978                .paths()
2979                .map(|p| p.to_string_lossy())
2980                .collect::<Vec<_>>(),
2981            ["a.txt", "b.txt", "c.txt"]
2982        );
2983    });
2984
2985    worktree_b.read_with(cx_b, |worktree, _| {
2986        assert_eq!(
2987            worktree
2988                .paths()
2989                .map(|p| p.to_string_lossy())
2990                .collect::<Vec<_>>(),
2991            ["a.txt", "b.txt", "c.txt"]
2992        );
2993    });
2994
2995    project_b
2996        .update(cx_b, |project, cx| {
2997            project.rename_entry(entry.id, Path::new("d.txt"), cx)
2998        })
2999        .await
3000        .unwrap()
3001        .unwrap();
3002
3003    worktree_a.read_with(cx_a, |worktree, _| {
3004        assert_eq!(
3005            worktree
3006                .paths()
3007                .map(|p| p.to_string_lossy())
3008                .collect::<Vec<_>>(),
3009            ["a.txt", "b.txt", "d.txt"]
3010        );
3011    });
3012
3013    worktree_b.read_with(cx_b, |worktree, _| {
3014        assert_eq!(
3015            worktree
3016                .paths()
3017                .map(|p| p.to_string_lossy())
3018                .collect::<Vec<_>>(),
3019            ["a.txt", "b.txt", "d.txt"]
3020        );
3021    });
3022
3023    let dir_entry = project_b
3024        .update(cx_b, |project, cx| {
3025            project.create_entry((worktree_id, "DIR"), true, cx)
3026        })
3027        .await
3028        .unwrap()
3029        .unwrap();
3030
3031    worktree_a.read_with(cx_a, |worktree, _| {
3032        assert_eq!(
3033            worktree
3034                .paths()
3035                .map(|p| p.to_string_lossy())
3036                .collect::<Vec<_>>(),
3037            ["DIR", "a.txt", "b.txt", "d.txt"]
3038        );
3039    });
3040
3041    worktree_b.read_with(cx_b, |worktree, _| {
3042        assert_eq!(
3043            worktree
3044                .paths()
3045                .map(|p| p.to_string_lossy())
3046                .collect::<Vec<_>>(),
3047            ["DIR", "a.txt", "b.txt", "d.txt"]
3048        );
3049    });
3050
3051    project_b
3052        .update(cx_b, |project, cx| {
3053            project.create_entry((worktree_id, "DIR/e.txt"), false, cx)
3054        })
3055        .await
3056        .unwrap()
3057        .unwrap();
3058    project_b
3059        .update(cx_b, |project, cx| {
3060            project.create_entry((worktree_id, "DIR/SUBDIR"), true, cx)
3061        })
3062        .await
3063        .unwrap()
3064        .unwrap();
3065    project_b
3066        .update(cx_b, |project, cx| {
3067            project.create_entry((worktree_id, "DIR/SUBDIR/f.txt"), false, cx)
3068        })
3069        .await
3070        .unwrap()
3071        .unwrap();
3072
3073    worktree_a.read_with(cx_a, |worktree, _| {
3074        assert_eq!(
3075            worktree
3076                .paths()
3077                .map(|p| p.to_string_lossy())
3078                .collect::<Vec<_>>(),
3079            [
3080                "DIR",
3081                "DIR/SUBDIR",
3082                "DIR/SUBDIR/f.txt",
3083                "DIR/e.txt",
3084                "a.txt",
3085                "b.txt",
3086                "d.txt"
3087            ]
3088        );
3089    });
3090
3091    worktree_b.read_with(cx_b, |worktree, _| {
3092        assert_eq!(
3093            worktree
3094                .paths()
3095                .map(|p| p.to_string_lossy())
3096                .collect::<Vec<_>>(),
3097            [
3098                "DIR",
3099                "DIR/SUBDIR",
3100                "DIR/SUBDIR/f.txt",
3101                "DIR/e.txt",
3102                "a.txt",
3103                "b.txt",
3104                "d.txt"
3105            ]
3106        );
3107    });
3108
3109    project_b
3110        .update(cx_b, |project, cx| {
3111            project.copy_entry(entry.id, Path::new("f.txt"), cx)
3112        })
3113        .await
3114        .unwrap()
3115        .unwrap();
3116
3117    worktree_a.read_with(cx_a, |worktree, _| {
3118        assert_eq!(
3119            worktree
3120                .paths()
3121                .map(|p| p.to_string_lossy())
3122                .collect::<Vec<_>>(),
3123            [
3124                "DIR",
3125                "DIR/SUBDIR",
3126                "DIR/SUBDIR/f.txt",
3127                "DIR/e.txt",
3128                "a.txt",
3129                "b.txt",
3130                "d.txt",
3131                "f.txt"
3132            ]
3133        );
3134    });
3135
3136    worktree_b.read_with(cx_b, |worktree, _| {
3137        assert_eq!(
3138            worktree
3139                .paths()
3140                .map(|p| p.to_string_lossy())
3141                .collect::<Vec<_>>(),
3142            [
3143                "DIR",
3144                "DIR/SUBDIR",
3145                "DIR/SUBDIR/f.txt",
3146                "DIR/e.txt",
3147                "a.txt",
3148                "b.txt",
3149                "d.txt",
3150                "f.txt"
3151            ]
3152        );
3153    });
3154
3155    project_b
3156        .update(cx_b, |project, cx| {
3157            project.delete_entry(dir_entry.id, cx).unwrap()
3158        })
3159        .await
3160        .unwrap();
3161    executor.run_until_parked();
3162
3163    worktree_a.read_with(cx_a, |worktree, _| {
3164        assert_eq!(
3165            worktree
3166                .paths()
3167                .map(|p| p.to_string_lossy())
3168                .collect::<Vec<_>>(),
3169            ["a.txt", "b.txt", "d.txt", "f.txt"]
3170        );
3171    });
3172
3173    worktree_b.read_with(cx_b, |worktree, _| {
3174        assert_eq!(
3175            worktree
3176                .paths()
3177                .map(|p| p.to_string_lossy())
3178                .collect::<Vec<_>>(),
3179            ["a.txt", "b.txt", "d.txt", "f.txt"]
3180        );
3181    });
3182
3183    project_b
3184        .update(cx_b, |project, cx| {
3185            project.delete_entry(entry.id, cx).unwrap()
3186        })
3187        .await
3188        .unwrap();
3189
3190    worktree_a.read_with(cx_a, |worktree, _| {
3191        assert_eq!(
3192            worktree
3193                .paths()
3194                .map(|p| p.to_string_lossy())
3195                .collect::<Vec<_>>(),
3196            ["a.txt", "b.txt", "f.txt"]
3197        );
3198    });
3199
3200    worktree_b.read_with(cx_b, |worktree, _| {
3201        assert_eq!(
3202            worktree
3203                .paths()
3204                .map(|p| p.to_string_lossy())
3205                .collect::<Vec<_>>(),
3206            ["a.txt", "b.txt", "f.txt"]
3207        );
3208    });
3209}
3210
3211#[gpui::test(iterations = 10)]
3212async fn test_local_settings(
3213    executor: BackgroundExecutor,
3214    cx_a: &mut TestAppContext,
3215    cx_b: &mut TestAppContext,
3216) {
3217    let mut server = TestServer::start(executor.clone()).await;
3218    let client_a = server.create_client(cx_a, "user_a").await;
3219    let client_b = server.create_client(cx_b, "user_b").await;
3220    server
3221        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
3222        .await;
3223    let active_call_a = cx_a.read(ActiveCall::global);
3224
3225    // As client A, open a project that contains some local settings files
3226    client_a
3227        .fs()
3228        .insert_tree(
3229            "/dir",
3230            json!({
3231                ".zed": {
3232                    "settings.json": r#"{ "tab_size": 2 }"#
3233                },
3234                "a": {
3235                    ".zed": {
3236                        "settings.json": r#"{ "tab_size": 8 }"#
3237                    },
3238                    "a.txt": "a-contents",
3239                },
3240                "b": {
3241                    "b.txt": "b-contents",
3242                }
3243            }),
3244        )
3245        .await;
3246    let (project_a, _) = client_a.build_local_project("/dir", cx_a).await;
3247    executor.run_until_parked();
3248    let project_id = active_call_a
3249        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
3250        .await
3251        .unwrap();
3252    executor.run_until_parked();
3253
3254    // As client B, join that project and observe the local settings.
3255    let project_b = client_b.build_remote_project(project_id, cx_b).await;
3256
3257    let worktree_b = project_b.read_with(cx_b, |project, _| project.worktrees().next().unwrap());
3258    executor.run_until_parked();
3259    cx_b.read(|cx| {
3260        let store = cx.global::<SettingsStore>();
3261        assert_eq!(
3262            store
3263                .local_settings(worktree_b.read(cx).id().to_usize())
3264                .collect::<Vec<_>>(),
3265            &[
3266                (Path::new("").into(), r#"{"tab_size":2}"#.to_string()),
3267                (Path::new("a").into(), r#"{"tab_size":8}"#.to_string()),
3268            ]
3269        )
3270    });
3271
3272    // As client A, update a settings file. As Client B, see the changed settings.
3273    client_a
3274        .fs()
3275        .insert_file("/dir/.zed/settings.json", r#"{}"#.into())
3276        .await;
3277    executor.run_until_parked();
3278    cx_b.read(|cx| {
3279        let store = cx.global::<SettingsStore>();
3280        assert_eq!(
3281            store
3282                .local_settings(worktree_b.read(cx).id().to_usize())
3283                .collect::<Vec<_>>(),
3284            &[
3285                (Path::new("").into(), r#"{}"#.to_string()),
3286                (Path::new("a").into(), r#"{"tab_size":8}"#.to_string()),
3287            ]
3288        )
3289    });
3290
3291    // As client A, create and remove some settings files. As client B, see the changed settings.
3292    client_a
3293        .fs()
3294        .remove_file("/dir/.zed/settings.json".as_ref(), Default::default())
3295        .await
3296        .unwrap();
3297    client_a
3298        .fs()
3299        .create_dir("/dir/b/.zed".as_ref())
3300        .await
3301        .unwrap();
3302    client_a
3303        .fs()
3304        .insert_file("/dir/b/.zed/settings.json", r#"{"tab_size": 4}"#.into())
3305        .await;
3306    executor.run_until_parked();
3307    cx_b.read(|cx| {
3308        let store = cx.global::<SettingsStore>();
3309        assert_eq!(
3310            store
3311                .local_settings(worktree_b.read(cx).id().to_usize())
3312                .collect::<Vec<_>>(),
3313            &[
3314                (Path::new("a").into(), r#"{"tab_size":8}"#.to_string()),
3315                (Path::new("b").into(), r#"{"tab_size":4}"#.to_string()),
3316            ]
3317        )
3318    });
3319
3320    // As client B, disconnect.
3321    server.forbid_connections();
3322    server.disconnect_client(client_b.peer_id().unwrap());
3323
3324    // As client A, change and remove settings files while client B is disconnected.
3325    client_a
3326        .fs()
3327        .insert_file("/dir/a/.zed/settings.json", r#"{"hard_tabs":true}"#.into())
3328        .await;
3329    client_a
3330        .fs()
3331        .remove_file("/dir/b/.zed/settings.json".as_ref(), Default::default())
3332        .await
3333        .unwrap();
3334    executor.run_until_parked();
3335
3336    // As client B, reconnect and see the changed settings.
3337    server.allow_connections();
3338    executor.advance_clock(RECEIVE_TIMEOUT);
3339    cx_b.read(|cx| {
3340        let store = cx.global::<SettingsStore>();
3341        assert_eq!(
3342            store
3343                .local_settings(worktree_b.read(cx).id().to_usize())
3344                .collect::<Vec<_>>(),
3345            &[(Path::new("a").into(), r#"{"hard_tabs":true}"#.to_string()),]
3346        )
3347    });
3348}
3349
3350#[gpui::test(iterations = 10)]
3351async fn test_buffer_conflict_after_save(
3352    executor: BackgroundExecutor,
3353    cx_a: &mut TestAppContext,
3354    cx_b: &mut TestAppContext,
3355) {
3356    let mut server = TestServer::start(executor.clone()).await;
3357    let client_a = server.create_client(cx_a, "user_a").await;
3358    let client_b = server.create_client(cx_b, "user_b").await;
3359    server
3360        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
3361        .await;
3362    let active_call_a = cx_a.read(ActiveCall::global);
3363
3364    client_a
3365        .fs()
3366        .insert_tree(
3367            "/dir",
3368            json!({
3369                "a.txt": "a-contents",
3370            }),
3371        )
3372        .await;
3373    let (project_a, worktree_id) = client_a.build_local_project("/dir", cx_a).await;
3374    let project_id = active_call_a
3375        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
3376        .await
3377        .unwrap();
3378    let project_b = client_b.build_remote_project(project_id, cx_b).await;
3379
3380    // Open a buffer as client B
3381    let buffer_b = project_b
3382        .update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
3383        .await
3384        .unwrap();
3385
3386    buffer_b.update(cx_b, |buf, cx| buf.edit([(0..0, "world ")], None, cx));
3387
3388    buffer_b.read_with(cx_b, |buf, _| {
3389        assert!(buf.is_dirty());
3390        assert!(!buf.has_conflict());
3391    });
3392
3393    project_b
3394        .update(cx_b, |project, cx| {
3395            project.save_buffer(buffer_b.clone(), cx)
3396        })
3397        .await
3398        .unwrap();
3399
3400    buffer_b.read_with(cx_b, |buffer_b, _| assert!(!buffer_b.is_dirty()));
3401
3402    buffer_b.read_with(cx_b, |buf, _| {
3403        assert!(!buf.has_conflict());
3404    });
3405
3406    buffer_b.update(cx_b, |buf, cx| buf.edit([(0..0, "hello ")], None, cx));
3407
3408    buffer_b.read_with(cx_b, |buf, _| {
3409        assert!(buf.is_dirty());
3410        assert!(!buf.has_conflict());
3411    });
3412}
3413
3414#[gpui::test(iterations = 10)]
3415async fn test_buffer_reloading(
3416    executor: BackgroundExecutor,
3417    cx_a: &mut TestAppContext,
3418    cx_b: &mut TestAppContext,
3419) {
3420    let mut server = TestServer::start(executor.clone()).await;
3421    let client_a = server.create_client(cx_a, "user_a").await;
3422    let client_b = server.create_client(cx_b, "user_b").await;
3423    server
3424        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
3425        .await;
3426    let active_call_a = cx_a.read(ActiveCall::global);
3427
3428    client_a
3429        .fs()
3430        .insert_tree(
3431            "/dir",
3432            json!({
3433                "a.txt": "a\nb\nc",
3434            }),
3435        )
3436        .await;
3437    let (project_a, worktree_id) = client_a.build_local_project("/dir", cx_a).await;
3438    let project_id = active_call_a
3439        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
3440        .await
3441        .unwrap();
3442    let project_b = client_b.build_remote_project(project_id, cx_b).await;
3443
3444    // Open a buffer as client B
3445    let buffer_b = project_b
3446        .update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
3447        .await
3448        .unwrap();
3449
3450    buffer_b.read_with(cx_b, |buf, _| {
3451        assert!(!buf.is_dirty());
3452        assert!(!buf.has_conflict());
3453        assert_eq!(buf.line_ending(), LineEnding::Unix);
3454    });
3455
3456    let new_contents = Rope::from("d\ne\nf");
3457    client_a
3458        .fs()
3459        .save("/dir/a.txt".as_ref(), &new_contents, LineEnding::Windows)
3460        .await
3461        .unwrap();
3462
3463    executor.run_until_parked();
3464
3465    buffer_b.read_with(cx_b, |buf, _| {
3466        assert_eq!(buf.text(), new_contents.to_string());
3467        assert!(!buf.is_dirty());
3468        assert!(!buf.has_conflict());
3469        assert_eq!(buf.line_ending(), LineEnding::Windows);
3470    });
3471}
3472
3473#[gpui::test(iterations = 10)]
3474async fn test_editing_while_guest_opens_buffer(
3475    executor: BackgroundExecutor,
3476    cx_a: &mut TestAppContext,
3477    cx_b: &mut TestAppContext,
3478) {
3479    let mut server = TestServer::start(executor.clone()).await;
3480    let client_a = server.create_client(cx_a, "user_a").await;
3481    let client_b = server.create_client(cx_b, "user_b").await;
3482    server
3483        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
3484        .await;
3485    let active_call_a = cx_a.read(ActiveCall::global);
3486
3487    client_a
3488        .fs()
3489        .insert_tree("/dir", json!({ "a.txt": "a-contents" }))
3490        .await;
3491    let (project_a, worktree_id) = client_a.build_local_project("/dir", cx_a).await;
3492    let project_id = active_call_a
3493        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
3494        .await
3495        .unwrap();
3496    let project_b = client_b.build_remote_project(project_id, cx_b).await;
3497
3498    // Open a buffer as client A
3499    let buffer_a = project_a
3500        .update(cx_a, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
3501        .await
3502        .unwrap();
3503
3504    // Start opening the same buffer as client B
3505    let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx));
3506    let buffer_b = cx_b.executor().spawn(open_buffer);
3507
3508    // Edit the buffer as client A while client B is still opening it.
3509    cx_b.executor().simulate_random_delay().await;
3510    buffer_a.update(cx_a, |buf, cx| buf.edit([(0..0, "X")], None, cx));
3511    cx_b.executor().simulate_random_delay().await;
3512    buffer_a.update(cx_a, |buf, cx| buf.edit([(1..1, "Y")], None, cx));
3513
3514    let text = buffer_a.read_with(cx_a, |buf, _| buf.text());
3515    let buffer_b = buffer_b.await.unwrap();
3516    executor.run_until_parked();
3517
3518    buffer_b.read_with(cx_b, |buf, _| assert_eq!(buf.text(), text));
3519}
3520
3521#[gpui::test(iterations = 10)]
3522async fn test_leaving_worktree_while_opening_buffer(
3523    executor: BackgroundExecutor,
3524    cx_a: &mut TestAppContext,
3525    cx_b: &mut TestAppContext,
3526) {
3527    let mut server = TestServer::start(executor.clone()).await;
3528    let client_a = server.create_client(cx_a, "user_a").await;
3529    let client_b = server.create_client(cx_b, "user_b").await;
3530    server
3531        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
3532        .await;
3533    let active_call_a = cx_a.read(ActiveCall::global);
3534
3535    client_a
3536        .fs()
3537        .insert_tree("/dir", json!({ "a.txt": "a-contents" }))
3538        .await;
3539    let (project_a, worktree_id) = client_a.build_local_project("/dir", cx_a).await;
3540    let project_id = active_call_a
3541        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
3542        .await
3543        .unwrap();
3544    let project_b = client_b.build_remote_project(project_id, cx_b).await;
3545
3546    // See that a guest has joined as client A.
3547    executor.run_until_parked();
3548
3549    project_a.read_with(cx_a, |p, _| assert_eq!(p.collaborators().len(), 1));
3550
3551    // Begin opening a buffer as client B, but leave the project before the open completes.
3552    let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx));
3553    let buffer_b = cx_b.executor().spawn(open_buffer);
3554    cx_b.update(|_| drop(project_b));
3555    drop(buffer_b);
3556
3557    // See that the guest has left.
3558    executor.run_until_parked();
3559
3560    project_a.read_with(cx_a, |p, _| assert!(p.collaborators().is_empty()));
3561}
3562
3563#[gpui::test(iterations = 10)]
3564async fn test_canceling_buffer_opening(
3565    executor: BackgroundExecutor,
3566    cx_a: &mut TestAppContext,
3567    cx_b: &mut TestAppContext,
3568) {
3569    let mut server = TestServer::start(executor.clone()).await;
3570    let client_a = server.create_client(cx_a, "user_a").await;
3571    let client_b = server.create_client(cx_b, "user_b").await;
3572    server
3573        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
3574        .await;
3575    let active_call_a = cx_a.read(ActiveCall::global);
3576
3577    client_a
3578        .fs()
3579        .insert_tree(
3580            "/dir",
3581            json!({
3582                "a.txt": "abc",
3583            }),
3584        )
3585        .await;
3586    let (project_a, worktree_id) = client_a.build_local_project("/dir", cx_a).await;
3587    let project_id = active_call_a
3588        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
3589        .await
3590        .unwrap();
3591    let project_b = client_b.build_remote_project(project_id, cx_b).await;
3592
3593    let buffer_a = project_a
3594        .update(cx_a, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
3595        .await
3596        .unwrap();
3597
3598    // Open a buffer as client B but cancel after a random amount of time.
3599    let buffer_b = project_b.update(cx_b, |p, cx| {
3600        p.open_buffer_by_id(buffer_a.read_with(cx_a, |a, _| a.remote_id()), cx)
3601    });
3602    executor.simulate_random_delay().await;
3603    drop(buffer_b);
3604
3605    // Try opening the same buffer again as client B, and ensure we can
3606    // still do it despite the cancellation above.
3607    let buffer_b = project_b
3608        .update(cx_b, |p, cx| {
3609            p.open_buffer_by_id(buffer_a.read_with(cx_a, |a, _| a.remote_id()), cx)
3610        })
3611        .await
3612        .unwrap();
3613
3614    buffer_b.read_with(cx_b, |buf, _| assert_eq!(buf.text(), "abc"));
3615}
3616
3617#[gpui::test(iterations = 10)]
3618async fn test_leaving_project(
3619    executor: BackgroundExecutor,
3620    cx_a: &mut TestAppContext,
3621    cx_b: &mut TestAppContext,
3622    cx_c: &mut TestAppContext,
3623) {
3624    let mut server = TestServer::start(executor.clone()).await;
3625    let client_a = server.create_client(cx_a, "user_a").await;
3626    let client_b = server.create_client(cx_b, "user_b").await;
3627    let client_c = server.create_client(cx_c, "user_c").await;
3628    server
3629        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b), (&client_c, cx_c)])
3630        .await;
3631    let active_call_a = cx_a.read(ActiveCall::global);
3632
3633    client_a
3634        .fs()
3635        .insert_tree(
3636            "/a",
3637            json!({
3638                "a.txt": "a-contents",
3639                "b.txt": "b-contents",
3640            }),
3641        )
3642        .await;
3643    let (project_a, _) = client_a.build_local_project("/a", cx_a).await;
3644    let project_id = active_call_a
3645        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
3646        .await
3647        .unwrap();
3648    let project_b1 = client_b.build_remote_project(project_id, cx_b).await;
3649    let project_c = client_c.build_remote_project(project_id, cx_c).await;
3650
3651    // Client A sees that a guest has joined.
3652    executor.run_until_parked();
3653
3654    project_a.read_with(cx_a, |project, _| {
3655        assert_eq!(project.collaborators().len(), 2);
3656    });
3657
3658    project_b1.read_with(cx_b, |project, _| {
3659        assert_eq!(project.collaborators().len(), 2);
3660    });
3661
3662    project_c.read_with(cx_c, |project, _| {
3663        assert_eq!(project.collaborators().len(), 2);
3664    });
3665
3666    // Client B opens a buffer.
3667    let buffer_b1 = project_b1
3668        .update(cx_b, |project, cx| {
3669            let worktree_id = project.worktrees().next().unwrap().read(cx).id();
3670            project.open_buffer((worktree_id, "a.txt"), cx)
3671        })
3672        .await
3673        .unwrap();
3674
3675    buffer_b1.read_with(cx_b, |buffer, _| assert_eq!(buffer.text(), "a-contents"));
3676
3677    // Drop client B's project and ensure client A and client C observe client B leaving.
3678    cx_b.update(|_| drop(project_b1));
3679    executor.run_until_parked();
3680
3681    project_a.read_with(cx_a, |project, _| {
3682        assert_eq!(project.collaborators().len(), 1);
3683    });
3684
3685    project_c.read_with(cx_c, |project, _| {
3686        assert_eq!(project.collaborators().len(), 1);
3687    });
3688
3689    // Client B re-joins the project and can open buffers as before.
3690    let project_b2 = client_b.build_remote_project(project_id, cx_b).await;
3691    executor.run_until_parked();
3692
3693    project_a.read_with(cx_a, |project, _| {
3694        assert_eq!(project.collaborators().len(), 2);
3695    });
3696
3697    project_b2.read_with(cx_b, |project, _| {
3698        assert_eq!(project.collaborators().len(), 2);
3699    });
3700
3701    project_c.read_with(cx_c, |project, _| {
3702        assert_eq!(project.collaborators().len(), 2);
3703    });
3704
3705    let buffer_b2 = project_b2
3706        .update(cx_b, |project, cx| {
3707            let worktree_id = project.worktrees().next().unwrap().read(cx).id();
3708            project.open_buffer((worktree_id, "a.txt"), cx)
3709        })
3710        .await
3711        .unwrap();
3712
3713    buffer_b2.read_with(cx_b, |buffer, _| assert_eq!(buffer.text(), "a-contents"));
3714
3715    // Drop client B's connection and ensure client A and client C observe client B leaving.
3716    client_b.disconnect(&cx_b.to_async());
3717    executor.advance_clock(RECONNECT_TIMEOUT);
3718
3719    project_a.read_with(cx_a, |project, _| {
3720        assert_eq!(project.collaborators().len(), 1);
3721    });
3722
3723    project_b2.read_with(cx_b, |project, _| {
3724        assert!(project.is_disconnected());
3725    });
3726
3727    project_c.read_with(cx_c, |project, _| {
3728        assert_eq!(project.collaborators().len(), 1);
3729    });
3730
3731    // Client B can't join the project, unless they re-join the room.
3732    cx_b.spawn(|cx| {
3733        Project::remote(
3734            project_id,
3735            client_b.app_state.client.clone(),
3736            client_b.user_store().clone(),
3737            client_b.language_registry().clone(),
3738            FakeFs::new(cx.background_executor().clone()),
3739            ChannelRole::Member,
3740            cx,
3741        )
3742    })
3743    .await
3744    .unwrap_err();
3745
3746    // Simulate connection loss for client C and ensure client A observes client C leaving the project.
3747    client_c.wait_for_current_user(cx_c).await;
3748    server.forbid_connections();
3749    server.disconnect_client(client_c.peer_id().unwrap());
3750    executor.advance_clock(RECEIVE_TIMEOUT + RECONNECT_TIMEOUT);
3751    executor.run_until_parked();
3752
3753    project_a.read_with(cx_a, |project, _| {
3754        assert_eq!(project.collaborators().len(), 0);
3755    });
3756
3757    project_b2.read_with(cx_b, |project, _| {
3758        assert!(project.is_disconnected());
3759    });
3760
3761    project_c.read_with(cx_c, |project, _| {
3762        assert!(project.is_disconnected());
3763    });
3764}
3765
3766#[gpui::test(iterations = 10)]
3767async fn test_collaborating_with_diagnostics(
3768    executor: BackgroundExecutor,
3769    cx_a: &mut TestAppContext,
3770    cx_b: &mut TestAppContext,
3771    cx_c: &mut TestAppContext,
3772) {
3773    let mut server = TestServer::start(executor.clone()).await;
3774    let client_a = server.create_client(cx_a, "user_a").await;
3775    let client_b = server.create_client(cx_b, "user_b").await;
3776    let client_c = server.create_client(cx_c, "user_c").await;
3777    server
3778        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b), (&client_c, cx_c)])
3779        .await;
3780    let active_call_a = cx_a.read(ActiveCall::global);
3781
3782    // Set up a fake language server.
3783    let mut language = Language::new(
3784        LanguageConfig {
3785            name: "Rust".into(),
3786            path_suffixes: vec!["rs".to_string()],
3787            ..Default::default()
3788        },
3789        Some(tree_sitter_rust::language()),
3790    );
3791    let mut fake_language_servers = language.set_fake_lsp_adapter(Default::default()).await;
3792    client_a.language_registry().add(Arc::new(language));
3793
3794    // Share a project as client A
3795    client_a
3796        .fs()
3797        .insert_tree(
3798            "/a",
3799            json!({
3800                "a.rs": "let one = two",
3801                "other.rs": "",
3802            }),
3803        )
3804        .await;
3805    let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
3806
3807    // Cause the language server to start.
3808    let _buffer = project_a
3809        .update(cx_a, |project, cx| {
3810            project.open_buffer(
3811                ProjectPath {
3812                    worktree_id,
3813                    path: Path::new("other.rs").into(),
3814                },
3815                cx,
3816            )
3817        })
3818        .await
3819        .unwrap();
3820
3821    // Simulate a language server reporting errors for a file.
3822    let mut fake_language_server = fake_language_servers.next().await.unwrap();
3823    fake_language_server
3824        .receive_notification::<lsp::notification::DidOpenTextDocument>()
3825        .await;
3826    fake_language_server.notify::<lsp::notification::PublishDiagnostics>(
3827        lsp::PublishDiagnosticsParams {
3828            uri: lsp::Url::from_file_path("/a/a.rs").unwrap(),
3829            version: None,
3830            diagnostics: vec![lsp::Diagnostic {
3831                severity: Some(lsp::DiagnosticSeverity::WARNING),
3832                range: lsp::Range::new(lsp::Position::new(0, 4), lsp::Position::new(0, 7)),
3833                message: "message 0".to_string(),
3834                ..Default::default()
3835            }],
3836        },
3837    );
3838
3839    // Client A shares the project and, simultaneously, the language server
3840    // publishes a diagnostic. This is done to ensure that the server always
3841    // observes the latest diagnostics for a worktree.
3842    let project_id = active_call_a
3843        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
3844        .await
3845        .unwrap();
3846    fake_language_server.notify::<lsp::notification::PublishDiagnostics>(
3847        lsp::PublishDiagnosticsParams {
3848            uri: lsp::Url::from_file_path("/a/a.rs").unwrap(),
3849            version: None,
3850            diagnostics: vec![lsp::Diagnostic {
3851                severity: Some(lsp::DiagnosticSeverity::ERROR),
3852                range: lsp::Range::new(lsp::Position::new(0, 4), lsp::Position::new(0, 7)),
3853                message: "message 1".to_string(),
3854                ..Default::default()
3855            }],
3856        },
3857    );
3858
3859    // Join the worktree as client B.
3860    let project_b = client_b.build_remote_project(project_id, cx_b).await;
3861
3862    // Wait for server to see the diagnostics update.
3863    executor.run_until_parked();
3864
3865    // Ensure client B observes the new diagnostics.
3866
3867    project_b.read_with(cx_b, |project, cx| {
3868        assert_eq!(
3869            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
3870            &[(
3871                ProjectPath {
3872                    worktree_id,
3873                    path: Arc::from(Path::new("a.rs")),
3874                },
3875                LanguageServerId(0),
3876                DiagnosticSummary {
3877                    error_count: 1,
3878                    warning_count: 0,
3879                    ..Default::default()
3880                },
3881            )]
3882        )
3883    });
3884
3885    // Join project as client C and observe the diagnostics.
3886    let project_c = client_c.build_remote_project(project_id, cx_c).await;
3887    let project_c_diagnostic_summaries =
3888        Rc::new(RefCell::new(project_c.read_with(cx_c, |project, cx| {
3889            project.diagnostic_summaries(false, cx).collect::<Vec<_>>()
3890        })));
3891    project_c.update(cx_c, |_, cx| {
3892        let summaries = project_c_diagnostic_summaries.clone();
3893        cx.subscribe(&project_c, {
3894            move |p, _, event, cx| {
3895                if let project::Event::DiskBasedDiagnosticsFinished { .. } = event {
3896                    *summaries.borrow_mut() = p.diagnostic_summaries(false, cx).collect();
3897                }
3898            }
3899        })
3900        .detach();
3901    });
3902
3903    executor.run_until_parked();
3904    assert_eq!(
3905        project_c_diagnostic_summaries.borrow().as_slice(),
3906        &[(
3907            ProjectPath {
3908                worktree_id,
3909                path: Arc::from(Path::new("a.rs")),
3910            },
3911            LanguageServerId(0),
3912            DiagnosticSummary {
3913                error_count: 1,
3914                warning_count: 0,
3915                ..Default::default()
3916            },
3917        )]
3918    );
3919
3920    // Simulate a language server reporting more errors for a file.
3921    fake_language_server.notify::<lsp::notification::PublishDiagnostics>(
3922        lsp::PublishDiagnosticsParams {
3923            uri: lsp::Url::from_file_path("/a/a.rs").unwrap(),
3924            version: None,
3925            diagnostics: vec![
3926                lsp::Diagnostic {
3927                    severity: Some(lsp::DiagnosticSeverity::ERROR),
3928                    range: lsp::Range::new(lsp::Position::new(0, 4), lsp::Position::new(0, 7)),
3929                    message: "message 1".to_string(),
3930                    ..Default::default()
3931                },
3932                lsp::Diagnostic {
3933                    severity: Some(lsp::DiagnosticSeverity::WARNING),
3934                    range: lsp::Range::new(lsp::Position::new(0, 10), lsp::Position::new(0, 13)),
3935                    message: "message 2".to_string(),
3936                    ..Default::default()
3937                },
3938            ],
3939        },
3940    );
3941
3942    // Clients B and C get the updated summaries
3943    executor.run_until_parked();
3944
3945    project_b.read_with(cx_b, |project, cx| {
3946        assert_eq!(
3947            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
3948            [(
3949                ProjectPath {
3950                    worktree_id,
3951                    path: Arc::from(Path::new("a.rs")),
3952                },
3953                LanguageServerId(0),
3954                DiagnosticSummary {
3955                    error_count: 1,
3956                    warning_count: 1,
3957                },
3958            )]
3959        );
3960    });
3961
3962    project_c.read_with(cx_c, |project, cx| {
3963        assert_eq!(
3964            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
3965            [(
3966                ProjectPath {
3967                    worktree_id,
3968                    path: Arc::from(Path::new("a.rs")),
3969                },
3970                LanguageServerId(0),
3971                DiagnosticSummary {
3972                    error_count: 1,
3973                    warning_count: 1,
3974                },
3975            )]
3976        );
3977    });
3978
3979    // Open the file with the errors on client B. They should be present.
3980    let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx));
3981    let buffer_b = cx_b.executor().spawn(open_buffer).await.unwrap();
3982
3983    buffer_b.read_with(cx_b, |buffer, _| {
3984        assert_eq!(
3985            buffer
3986                .snapshot()
3987                .diagnostics_in_range::<_, Point>(0..buffer.len(), false)
3988                .collect::<Vec<_>>(),
3989            &[
3990                DiagnosticEntry {
3991                    range: Point::new(0, 4)..Point::new(0, 7),
3992                    diagnostic: Diagnostic {
3993                        group_id: 2,
3994                        message: "message 1".to_string(),
3995                        severity: lsp::DiagnosticSeverity::ERROR,
3996                        is_primary: true,
3997                        ..Default::default()
3998                    }
3999                },
4000                DiagnosticEntry {
4001                    range: Point::new(0, 10)..Point::new(0, 13),
4002                    diagnostic: Diagnostic {
4003                        group_id: 3,
4004                        severity: lsp::DiagnosticSeverity::WARNING,
4005                        message: "message 2".to_string(),
4006                        is_primary: true,
4007                        ..Default::default()
4008                    }
4009                }
4010            ]
4011        );
4012    });
4013
4014    // Simulate a language server reporting no errors for a file.
4015    fake_language_server.notify::<lsp::notification::PublishDiagnostics>(
4016        lsp::PublishDiagnosticsParams {
4017            uri: lsp::Url::from_file_path("/a/a.rs").unwrap(),
4018            version: None,
4019            diagnostics: vec![],
4020        },
4021    );
4022    executor.run_until_parked();
4023
4024    project_a.read_with(cx_a, |project, cx| {
4025        assert_eq!(
4026            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
4027            []
4028        )
4029    });
4030
4031    project_b.read_with(cx_b, |project, cx| {
4032        assert_eq!(
4033            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
4034            []
4035        )
4036    });
4037
4038    project_c.read_with(cx_c, |project, cx| {
4039        assert_eq!(
4040            project.diagnostic_summaries(false, cx).collect::<Vec<_>>(),
4041            []
4042        )
4043    });
4044}
4045
4046#[gpui::test(iterations = 10)]
4047async fn test_collaborating_with_lsp_progress_updates_and_diagnostics_ordering(
4048    executor: BackgroundExecutor,
4049    cx_a: &mut TestAppContext,
4050    cx_b: &mut TestAppContext,
4051) {
4052    let mut server = TestServer::start(executor.clone()).await;
4053    let client_a = server.create_client(cx_a, "user_a").await;
4054    let client_b = server.create_client(cx_b, "user_b").await;
4055    server
4056        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
4057        .await;
4058
4059    // Set up a fake language server.
4060    let mut language = Language::new(
4061        LanguageConfig {
4062            name: "Rust".into(),
4063            path_suffixes: vec!["rs".to_string()],
4064            ..Default::default()
4065        },
4066        Some(tree_sitter_rust::language()),
4067    );
4068    let mut fake_language_servers = language
4069        .set_fake_lsp_adapter(Arc::new(FakeLspAdapter {
4070            disk_based_diagnostics_progress_token: Some("the-disk-based-token".into()),
4071            disk_based_diagnostics_sources: vec!["the-disk-based-diagnostics-source".into()],
4072            ..Default::default()
4073        }))
4074        .await;
4075    client_a.language_registry().add(Arc::new(language));
4076
4077    let file_names = &["one.rs", "two.rs", "three.rs", "four.rs", "five.rs"];
4078    client_a
4079        .fs()
4080        .insert_tree(
4081            "/test",
4082            json!({
4083                "one.rs": "const ONE: usize = 1;",
4084                "two.rs": "const TWO: usize = 2;",
4085                "three.rs": "const THREE: usize = 3;",
4086                "four.rs": "const FOUR: usize = 3;",
4087                "five.rs": "const FIVE: usize = 3;",
4088            }),
4089        )
4090        .await;
4091
4092    let (project_a, worktree_id) = client_a.build_local_project("/test", cx_a).await;
4093
4094    // Share a project as client A
4095    let active_call_a = cx_a.read(ActiveCall::global);
4096    let project_id = active_call_a
4097        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
4098        .await
4099        .unwrap();
4100
4101    // Join the project as client B and open all three files.
4102    let project_b = client_b.build_remote_project(project_id, cx_b).await;
4103    let guest_buffers = futures::future::try_join_all(file_names.iter().map(|file_name| {
4104        project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, file_name), cx))
4105    }))
4106    .await
4107    .unwrap();
4108
4109    // Simulate a language server reporting errors for a file.
4110    let fake_language_server = fake_language_servers.next().await.unwrap();
4111    fake_language_server
4112        .request::<lsp::request::WorkDoneProgressCreate>(lsp::WorkDoneProgressCreateParams {
4113            token: lsp::NumberOrString::String("the-disk-based-token".to_string()),
4114        })
4115        .await
4116        .unwrap();
4117    fake_language_server.notify::<lsp::notification::Progress>(lsp::ProgressParams {
4118        token: lsp::NumberOrString::String("the-disk-based-token".to_string()),
4119        value: lsp::ProgressParamsValue::WorkDone(lsp::WorkDoneProgress::Begin(
4120            lsp::WorkDoneProgressBegin {
4121                title: "Progress Began".into(),
4122                ..Default::default()
4123            },
4124        )),
4125    });
4126    for file_name in file_names {
4127        fake_language_server.notify::<lsp::notification::PublishDiagnostics>(
4128            lsp::PublishDiagnosticsParams {
4129                uri: lsp::Url::from_file_path(Path::new("/test").join(file_name)).unwrap(),
4130                version: None,
4131                diagnostics: vec![lsp::Diagnostic {
4132                    severity: Some(lsp::DiagnosticSeverity::WARNING),
4133                    source: Some("the-disk-based-diagnostics-source".into()),
4134                    range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 0)),
4135                    message: "message one".to_string(),
4136                    ..Default::default()
4137                }],
4138            },
4139        );
4140    }
4141    fake_language_server.notify::<lsp::notification::Progress>(lsp::ProgressParams {
4142        token: lsp::NumberOrString::String("the-disk-based-token".to_string()),
4143        value: lsp::ProgressParamsValue::WorkDone(lsp::WorkDoneProgress::End(
4144            lsp::WorkDoneProgressEnd { message: None },
4145        )),
4146    });
4147
4148    // When the "disk base diagnostics finished" message is received, the buffers'
4149    // diagnostics are expected to be present.
4150    let disk_based_diagnostics_finished = Arc::new(AtomicBool::new(false));
4151    project_b.update(cx_b, {
4152        let project_b = project_b.clone();
4153        let disk_based_diagnostics_finished = disk_based_diagnostics_finished.clone();
4154        move |_, cx| {
4155            cx.subscribe(&project_b, move |_, _, event, cx| {
4156                if let project::Event::DiskBasedDiagnosticsFinished { .. } = event {
4157                    disk_based_diagnostics_finished.store(true, SeqCst);
4158                    for buffer in &guest_buffers {
4159                        assert_eq!(
4160                            buffer
4161                                .read(cx)
4162                                .snapshot()
4163                                .diagnostics_in_range::<_, usize>(0..5, false)
4164                                .count(),
4165                            1,
4166                            "expected a diagnostic for buffer {:?}",
4167                            buffer.read(cx).file().unwrap().path(),
4168                        );
4169                    }
4170                }
4171            })
4172            .detach();
4173        }
4174    });
4175
4176    executor.run_until_parked();
4177    assert!(disk_based_diagnostics_finished.load(SeqCst));
4178}
4179
4180#[gpui::test(iterations = 10)]
4181async fn test_reloading_buffer_manually(
4182    executor: BackgroundExecutor,
4183    cx_a: &mut TestAppContext,
4184    cx_b: &mut TestAppContext,
4185) {
4186    let mut server = TestServer::start(executor.clone()).await;
4187    let client_a = server.create_client(cx_a, "user_a").await;
4188    let client_b = server.create_client(cx_b, "user_b").await;
4189    server
4190        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
4191        .await;
4192    let active_call_a = cx_a.read(ActiveCall::global);
4193
4194    client_a
4195        .fs()
4196        .insert_tree("/a", json!({ "a.rs": "let one = 1;" }))
4197        .await;
4198    let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
4199    let buffer_a = project_a
4200        .update(cx_a, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx))
4201        .await
4202        .unwrap();
4203    let project_id = active_call_a
4204        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
4205        .await
4206        .unwrap();
4207
4208    let project_b = client_b.build_remote_project(project_id, cx_b).await;
4209
4210    let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx));
4211    let buffer_b = cx_b.executor().spawn(open_buffer).await.unwrap();
4212    buffer_b.update(cx_b, |buffer, cx| {
4213        buffer.edit([(4..7, "six")], None, cx);
4214        buffer.edit([(10..11, "6")], None, cx);
4215        assert_eq!(buffer.text(), "let six = 6;");
4216        assert!(buffer.is_dirty());
4217        assert!(!buffer.has_conflict());
4218    });
4219    executor.run_until_parked();
4220
4221    buffer_a.read_with(cx_a, |buffer, _| assert_eq!(buffer.text(), "let six = 6;"));
4222
4223    client_a
4224        .fs()
4225        .save(
4226            "/a/a.rs".as_ref(),
4227            &Rope::from("let seven = 7;"),
4228            LineEnding::Unix,
4229        )
4230        .await
4231        .unwrap();
4232    executor.run_until_parked();
4233
4234    buffer_a.read_with(cx_a, |buffer, _| assert!(buffer.has_conflict()));
4235
4236    buffer_b.read_with(cx_b, |buffer, _| assert!(buffer.has_conflict()));
4237
4238    project_b
4239        .update(cx_b, |project, cx| {
4240            project.reload_buffers(HashSet::from_iter([buffer_b.clone()]), true, cx)
4241        })
4242        .await
4243        .unwrap();
4244
4245    buffer_a.read_with(cx_a, |buffer, _| {
4246        assert_eq!(buffer.text(), "let seven = 7;");
4247        assert!(!buffer.is_dirty());
4248        assert!(!buffer.has_conflict());
4249    });
4250
4251    buffer_b.read_with(cx_b, |buffer, _| {
4252        assert_eq!(buffer.text(), "let seven = 7;");
4253        assert!(!buffer.is_dirty());
4254        assert!(!buffer.has_conflict());
4255    });
4256
4257    buffer_a.update(cx_a, |buffer, cx| {
4258        // Undoing on the host is a no-op when the reload was initiated by the guest.
4259        buffer.undo(cx);
4260        assert_eq!(buffer.text(), "let seven = 7;");
4261        assert!(!buffer.is_dirty());
4262        assert!(!buffer.has_conflict());
4263    });
4264    buffer_b.update(cx_b, |buffer, cx| {
4265        // Undoing on the guest rolls back the buffer to before it was reloaded but the conflict gets cleared.
4266        buffer.undo(cx);
4267        assert_eq!(buffer.text(), "let six = 6;");
4268        assert!(buffer.is_dirty());
4269        assert!(!buffer.has_conflict());
4270    });
4271}
4272
4273#[gpui::test(iterations = 10)]
4274async fn test_formatting_buffer(
4275    executor: BackgroundExecutor,
4276    cx_a: &mut TestAppContext,
4277    cx_b: &mut TestAppContext,
4278) {
4279    executor.allow_parking();
4280    let mut server = TestServer::start(executor.clone()).await;
4281    let client_a = server.create_client(cx_a, "user_a").await;
4282    let client_b = server.create_client(cx_b, "user_b").await;
4283    server
4284        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
4285        .await;
4286    let active_call_a = cx_a.read(ActiveCall::global);
4287
4288    // Set up a fake language server.
4289    let mut language = Language::new(
4290        LanguageConfig {
4291            name: "Rust".into(),
4292            path_suffixes: vec!["rs".to_string()],
4293            ..Default::default()
4294        },
4295        Some(tree_sitter_rust::language()),
4296    );
4297    let mut fake_language_servers = language.set_fake_lsp_adapter(Default::default()).await;
4298    client_a.language_registry().add(Arc::new(language));
4299
4300    // Here we insert a fake tree with a directory that exists on disk. This is needed
4301    // because later we'll invoke a command, which requires passing a working directory
4302    // that points to a valid location on disk.
4303    let directory = env::current_dir().unwrap();
4304    client_a
4305        .fs()
4306        .insert_tree(&directory, json!({ "a.rs": "let one = \"two\"" }))
4307        .await;
4308    let (project_a, worktree_id) = client_a.build_local_project(&directory, cx_a).await;
4309    let project_id = active_call_a
4310        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
4311        .await
4312        .unwrap();
4313    let project_b = client_b.build_remote_project(project_id, cx_b).await;
4314
4315    let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx));
4316    let buffer_b = cx_b.executor().spawn(open_buffer).await.unwrap();
4317
4318    let fake_language_server = fake_language_servers.next().await.unwrap();
4319    fake_language_server.handle_request::<lsp::request::Formatting, _, _>(|_, _| async move {
4320        Ok(Some(vec![
4321            lsp::TextEdit {
4322                range: lsp::Range::new(lsp::Position::new(0, 4), lsp::Position::new(0, 4)),
4323                new_text: "h".to_string(),
4324            },
4325            lsp::TextEdit {
4326                range: lsp::Range::new(lsp::Position::new(0, 7), lsp::Position::new(0, 7)),
4327                new_text: "y".to_string(),
4328            },
4329        ]))
4330    });
4331
4332    project_b
4333        .update(cx_b, |project, cx| {
4334            project.format(
4335                HashSet::from_iter([buffer_b.clone()]),
4336                true,
4337                FormatTrigger::Save,
4338                cx,
4339            )
4340        })
4341        .await
4342        .unwrap();
4343
4344    // The edits from the LSP are applied, and a final newline is added.
4345    assert_eq!(
4346        buffer_b.read_with(cx_b, |buffer, _| buffer.text()),
4347        "let honey = \"two\"\n"
4348    );
4349
4350    // Ensure buffer can be formatted using an external command. Notice how the
4351    // host's configuration is honored as opposed to using the guest's settings.
4352    cx_a.update(|cx| {
4353        cx.update_global(|store: &mut SettingsStore, cx| {
4354            store.update_user_settings::<AllLanguageSettings>(cx, |file| {
4355                file.defaults.formatter = Some(Formatter::External {
4356                    command: "awk".into(),
4357                    arguments: vec!["{sub(/two/,\"{buffer_path}\")}1".to_string()].into(),
4358                });
4359            });
4360        });
4361    });
4362    project_b
4363        .update(cx_b, |project, cx| {
4364            project.format(
4365                HashSet::from_iter([buffer_b.clone()]),
4366                true,
4367                FormatTrigger::Save,
4368                cx,
4369            )
4370        })
4371        .await
4372        .unwrap();
4373    assert_eq!(
4374        buffer_b.read_with(cx_b, |buffer, _| buffer.text()),
4375        format!("let honey = \"{}/a.rs\"\n", directory.to_str().unwrap())
4376    );
4377}
4378
4379#[gpui::test(iterations = 10)]
4380async fn test_prettier_formatting_buffer(
4381    executor: BackgroundExecutor,
4382    cx_a: &mut TestAppContext,
4383    cx_b: &mut TestAppContext,
4384) {
4385    let mut server = TestServer::start(executor.clone()).await;
4386    let client_a = server.create_client(cx_a, "user_a").await;
4387    let client_b = server.create_client(cx_b, "user_b").await;
4388    server
4389        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
4390        .await;
4391    let active_call_a = cx_a.read(ActiveCall::global);
4392
4393    // Set up a fake language server.
4394    let mut language = Language::new(
4395        LanguageConfig {
4396            name: "Rust".into(),
4397            path_suffixes: vec!["rs".to_string()],
4398            prettier_parser_name: Some("test_parser".to_string()),
4399            ..Default::default()
4400        },
4401        Some(tree_sitter_rust::language()),
4402    );
4403    let test_plugin = "test_plugin";
4404    let mut fake_language_servers = language
4405        .set_fake_lsp_adapter(Arc::new(FakeLspAdapter {
4406            prettier_plugins: vec![test_plugin],
4407            ..Default::default()
4408        }))
4409        .await;
4410    let language = Arc::new(language);
4411    client_a.language_registry().add(Arc::clone(&language));
4412
4413    // Here we insert a fake tree with a directory that exists on disk. This is needed
4414    // because later we'll invoke a command, which requires passing a working directory
4415    // that points to a valid location on disk.
4416    let directory = env::current_dir().unwrap();
4417    let buffer_text = "let one = \"two\"";
4418    client_a
4419        .fs()
4420        .insert_tree(&directory, json!({ "a.rs": buffer_text }))
4421        .await;
4422    let (project_a, worktree_id) = client_a.build_local_project(&directory, cx_a).await;
4423    let prettier_format_suffix = project::TEST_PRETTIER_FORMAT_SUFFIX;
4424    let open_buffer = project_a.update(cx_a, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx));
4425    let buffer_a = cx_a.executor().spawn(open_buffer).await.unwrap();
4426
4427    let project_id = active_call_a
4428        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
4429        .await
4430        .unwrap();
4431    let project_b = client_b.build_remote_project(project_id, cx_b).await;
4432    let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx));
4433    let buffer_b = cx_b.executor().spawn(open_buffer).await.unwrap();
4434
4435    cx_a.update(|cx| {
4436        cx.update_global(|store: &mut SettingsStore, cx| {
4437            store.update_user_settings::<AllLanguageSettings>(cx, |file| {
4438                file.defaults.formatter = Some(Formatter::Auto);
4439            });
4440        });
4441    });
4442    cx_b.update(|cx| {
4443        cx.update_global(|store: &mut SettingsStore, cx| {
4444            store.update_user_settings::<AllLanguageSettings>(cx, |file| {
4445                file.defaults.formatter = Some(Formatter::LanguageServer);
4446            });
4447        });
4448    });
4449    let fake_language_server = fake_language_servers.next().await.unwrap();
4450    fake_language_server.handle_request::<lsp::request::Formatting, _, _>(|_, _| async move {
4451        panic!(
4452            "Unexpected: prettier should be preferred since it's enabled and language supports it"
4453        )
4454    });
4455
4456    project_b
4457        .update(cx_b, |project, cx| {
4458            project.format(
4459                HashSet::from_iter([buffer_b.clone()]),
4460                true,
4461                FormatTrigger::Save,
4462                cx,
4463            )
4464        })
4465        .await
4466        .unwrap();
4467
4468    executor.run_until_parked();
4469    assert_eq!(
4470        buffer_b.read_with(cx_b, |buffer, _| buffer.text()),
4471        buffer_text.to_string() + "\n" + prettier_format_suffix,
4472        "Prettier formatting was not applied to client buffer after client's request"
4473    );
4474
4475    project_a
4476        .update(cx_a, |project, cx| {
4477            project.format(
4478                HashSet::from_iter([buffer_a.clone()]),
4479                true,
4480                FormatTrigger::Manual,
4481                cx,
4482            )
4483        })
4484        .await
4485        .unwrap();
4486
4487    executor.run_until_parked();
4488    assert_eq!(
4489        buffer_b.read_with(cx_b, |buffer, _| buffer.text()),
4490        buffer_text.to_string() + "\n" + prettier_format_suffix + "\n" + prettier_format_suffix,
4491        "Prettier formatting was not applied to client buffer after host's request"
4492    );
4493}
4494
4495#[gpui::test(iterations = 10)]
4496async fn test_definition(
4497    executor: BackgroundExecutor,
4498    cx_a: &mut TestAppContext,
4499    cx_b: &mut TestAppContext,
4500) {
4501    let mut server = TestServer::start(executor.clone()).await;
4502    let client_a = server.create_client(cx_a, "user_a").await;
4503    let client_b = server.create_client(cx_b, "user_b").await;
4504    server
4505        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
4506        .await;
4507    let active_call_a = cx_a.read(ActiveCall::global);
4508
4509    // Set up a fake language server.
4510    let mut language = Language::new(
4511        LanguageConfig {
4512            name: "Rust".into(),
4513            path_suffixes: vec!["rs".to_string()],
4514            ..Default::default()
4515        },
4516        Some(tree_sitter_rust::language()),
4517    );
4518    let mut fake_language_servers = language.set_fake_lsp_adapter(Default::default()).await;
4519    client_a.language_registry().add(Arc::new(language));
4520
4521    client_a
4522        .fs()
4523        .insert_tree(
4524            "/root",
4525            json!({
4526                "dir-1": {
4527                    "a.rs": "const ONE: usize = b::TWO + b::THREE;",
4528                },
4529                "dir-2": {
4530                    "b.rs": "const TWO: c::T2 = 2;\nconst THREE: usize = 3;",
4531                    "c.rs": "type T2 = usize;",
4532                }
4533            }),
4534        )
4535        .await;
4536    let (project_a, worktree_id) = client_a.build_local_project("/root/dir-1", cx_a).await;
4537    let project_id = active_call_a
4538        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
4539        .await
4540        .unwrap();
4541    let project_b = client_b.build_remote_project(project_id, cx_b).await;
4542
4543    // Open the file on client B.
4544    let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx));
4545    let buffer_b = cx_b.executor().spawn(open_buffer).await.unwrap();
4546
4547    // Request the definition of a symbol as the guest.
4548    let fake_language_server = fake_language_servers.next().await.unwrap();
4549    fake_language_server.handle_request::<lsp::request::GotoDefinition, _, _>(|_, _| async move {
4550        Ok(Some(lsp::GotoDefinitionResponse::Scalar(
4551            lsp::Location::new(
4552                lsp::Url::from_file_path("/root/dir-2/b.rs").unwrap(),
4553                lsp::Range::new(lsp::Position::new(0, 6), lsp::Position::new(0, 9)),
4554            ),
4555        )))
4556    });
4557
4558    let definitions_1 = project_b
4559        .update(cx_b, |p, cx| p.definition(&buffer_b, 23, cx))
4560        .await
4561        .unwrap();
4562    cx_b.read(|cx| {
4563        assert_eq!(definitions_1.len(), 1);
4564        assert_eq!(project_b.read(cx).worktrees().count(), 2);
4565        let target_buffer = definitions_1[0].target.buffer.read(cx);
4566        assert_eq!(
4567            target_buffer.text(),
4568            "const TWO: c::T2 = 2;\nconst THREE: usize = 3;"
4569        );
4570        assert_eq!(
4571            definitions_1[0].target.range.to_point(target_buffer),
4572            Point::new(0, 6)..Point::new(0, 9)
4573        );
4574    });
4575
4576    // Try getting more definitions for the same buffer, ensuring the buffer gets reused from
4577    // the previous call to `definition`.
4578    fake_language_server.handle_request::<lsp::request::GotoDefinition, _, _>(|_, _| async move {
4579        Ok(Some(lsp::GotoDefinitionResponse::Scalar(
4580            lsp::Location::new(
4581                lsp::Url::from_file_path("/root/dir-2/b.rs").unwrap(),
4582                lsp::Range::new(lsp::Position::new(1, 6), lsp::Position::new(1, 11)),
4583            ),
4584        )))
4585    });
4586
4587    let definitions_2 = project_b
4588        .update(cx_b, |p, cx| p.definition(&buffer_b, 33, cx))
4589        .await
4590        .unwrap();
4591    cx_b.read(|cx| {
4592        assert_eq!(definitions_2.len(), 1);
4593        assert_eq!(project_b.read(cx).worktrees().count(), 2);
4594        let target_buffer = definitions_2[0].target.buffer.read(cx);
4595        assert_eq!(
4596            target_buffer.text(),
4597            "const TWO: c::T2 = 2;\nconst THREE: usize = 3;"
4598        );
4599        assert_eq!(
4600            definitions_2[0].target.range.to_point(target_buffer),
4601            Point::new(1, 6)..Point::new(1, 11)
4602        );
4603    });
4604    assert_eq!(
4605        definitions_1[0].target.buffer,
4606        definitions_2[0].target.buffer
4607    );
4608
4609    fake_language_server.handle_request::<lsp::request::GotoTypeDefinition, _, _>(
4610        |req, _| async move {
4611            assert_eq!(
4612                req.text_document_position_params.position,
4613                lsp::Position::new(0, 7)
4614            );
4615            Ok(Some(lsp::GotoDefinitionResponse::Scalar(
4616                lsp::Location::new(
4617                    lsp::Url::from_file_path("/root/dir-2/c.rs").unwrap(),
4618                    lsp::Range::new(lsp::Position::new(0, 5), lsp::Position::new(0, 7)),
4619                ),
4620            )))
4621        },
4622    );
4623
4624    let type_definitions = project_b
4625        .update(cx_b, |p, cx| p.type_definition(&buffer_b, 7, cx))
4626        .await
4627        .unwrap();
4628    cx_b.read(|cx| {
4629        assert_eq!(type_definitions.len(), 1);
4630        let target_buffer = type_definitions[0].target.buffer.read(cx);
4631        assert_eq!(target_buffer.text(), "type T2 = usize;");
4632        assert_eq!(
4633            type_definitions[0].target.range.to_point(target_buffer),
4634            Point::new(0, 5)..Point::new(0, 7)
4635        );
4636    });
4637}
4638
4639#[gpui::test(iterations = 10)]
4640async fn test_references(
4641    executor: BackgroundExecutor,
4642    cx_a: &mut TestAppContext,
4643    cx_b: &mut TestAppContext,
4644) {
4645    let mut server = TestServer::start(executor.clone()).await;
4646    let client_a = server.create_client(cx_a, "user_a").await;
4647    let client_b = server.create_client(cx_b, "user_b").await;
4648    server
4649        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
4650        .await;
4651    let active_call_a = cx_a.read(ActiveCall::global);
4652
4653    // Set up a fake language server.
4654    let mut language = Language::new(
4655        LanguageConfig {
4656            name: "Rust".into(),
4657            path_suffixes: vec!["rs".to_string()],
4658            ..Default::default()
4659        },
4660        Some(tree_sitter_rust::language()),
4661    );
4662    let mut fake_language_servers = language.set_fake_lsp_adapter(Default::default()).await;
4663    client_a.language_registry().add(Arc::new(language));
4664
4665    client_a
4666        .fs()
4667        .insert_tree(
4668            "/root",
4669            json!({
4670                "dir-1": {
4671                    "one.rs": "const ONE: usize = 1;",
4672                    "two.rs": "const TWO: usize = one::ONE + one::ONE;",
4673                },
4674                "dir-2": {
4675                    "three.rs": "const THREE: usize = two::TWO + one::ONE;",
4676                }
4677            }),
4678        )
4679        .await;
4680    let (project_a, worktree_id) = client_a.build_local_project("/root/dir-1", cx_a).await;
4681    let project_id = active_call_a
4682        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
4683        .await
4684        .unwrap();
4685    let project_b = client_b.build_remote_project(project_id, cx_b).await;
4686
4687    // Open the file on client B.
4688    let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "one.rs"), cx));
4689    let buffer_b = cx_b.executor().spawn(open_buffer).await.unwrap();
4690
4691    // Request references to a symbol as the guest.
4692    let fake_language_server = fake_language_servers.next().await.unwrap();
4693    fake_language_server.handle_request::<lsp::request::References, _, _>(|params, _| async move {
4694        assert_eq!(
4695            params.text_document_position.text_document.uri.as_str(),
4696            "file:///root/dir-1/one.rs"
4697        );
4698        Ok(Some(vec![
4699            lsp::Location {
4700                uri: lsp::Url::from_file_path("/root/dir-1/two.rs").unwrap(),
4701                range: lsp::Range::new(lsp::Position::new(0, 24), lsp::Position::new(0, 27)),
4702            },
4703            lsp::Location {
4704                uri: lsp::Url::from_file_path("/root/dir-1/two.rs").unwrap(),
4705                range: lsp::Range::new(lsp::Position::new(0, 35), lsp::Position::new(0, 38)),
4706            },
4707            lsp::Location {
4708                uri: lsp::Url::from_file_path("/root/dir-2/three.rs").unwrap(),
4709                range: lsp::Range::new(lsp::Position::new(0, 37), lsp::Position::new(0, 40)),
4710            },
4711        ]))
4712    });
4713
4714    let references = project_b
4715        .update(cx_b, |p, cx| p.references(&buffer_b, 7, cx))
4716        .await
4717        .unwrap();
4718    cx_b.read(|cx| {
4719        assert_eq!(references.len(), 3);
4720        assert_eq!(project_b.read(cx).worktrees().count(), 2);
4721
4722        let two_buffer = references[0].buffer.read(cx);
4723        let three_buffer = references[2].buffer.read(cx);
4724        assert_eq!(
4725            two_buffer.file().unwrap().path().as_ref(),
4726            Path::new("two.rs")
4727        );
4728        assert_eq!(references[1].buffer, references[0].buffer);
4729        assert_eq!(
4730            three_buffer.file().unwrap().full_path(cx),
4731            Path::new("/root/dir-2/three.rs")
4732        );
4733
4734        assert_eq!(references[0].range.to_offset(two_buffer), 24..27);
4735        assert_eq!(references[1].range.to_offset(two_buffer), 35..38);
4736        assert_eq!(references[2].range.to_offset(three_buffer), 37..40);
4737    });
4738}
4739
4740#[gpui::test(iterations = 10)]
4741async fn test_project_search(
4742    executor: BackgroundExecutor,
4743    cx_a: &mut TestAppContext,
4744    cx_b: &mut TestAppContext,
4745) {
4746    let mut server = TestServer::start(executor.clone()).await;
4747    let client_a = server.create_client(cx_a, "user_a").await;
4748    let client_b = server.create_client(cx_b, "user_b").await;
4749    server
4750        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
4751        .await;
4752    let active_call_a = cx_a.read(ActiveCall::global);
4753
4754    client_a
4755        .fs()
4756        .insert_tree(
4757            "/root",
4758            json!({
4759                "dir-1": {
4760                    "a": "hello world",
4761                    "b": "goodnight moon",
4762                    "c": "a world of goo",
4763                    "d": "world champion of clown world",
4764                },
4765                "dir-2": {
4766                    "e": "disney world is fun",
4767                }
4768            }),
4769        )
4770        .await;
4771    let (project_a, _) = client_a.build_local_project("/root/dir-1", cx_a).await;
4772    let (worktree_2, _) = project_a
4773        .update(cx_a, |p, cx| {
4774            p.find_or_create_local_worktree("/root/dir-2", true, cx)
4775        })
4776        .await
4777        .unwrap();
4778    worktree_2
4779        .read_with(cx_a, |tree, _| tree.as_local().unwrap().scan_complete())
4780        .await;
4781    let project_id = active_call_a
4782        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
4783        .await
4784        .unwrap();
4785
4786    let project_b = client_b.build_remote_project(project_id, cx_b).await;
4787
4788    // Perform a search as the guest.
4789    let mut results = HashMap::default();
4790    let mut search_rx = project_b.update(cx_b, |project, cx| {
4791        project.search(
4792            SearchQuery::text("world", false, false, false, Vec::new(), Vec::new()).unwrap(),
4793            cx,
4794        )
4795    });
4796    while let Some((buffer, ranges)) = search_rx.next().await {
4797        results.entry(buffer).or_insert(ranges);
4798    }
4799
4800    let mut ranges_by_path = results
4801        .into_iter()
4802        .map(|(buffer, ranges)| {
4803            buffer.read_with(cx_b, |buffer, cx| {
4804                let path = buffer.file().unwrap().full_path(cx);
4805                let offset_ranges = ranges
4806                    .into_iter()
4807                    .map(|range| range.to_offset(buffer))
4808                    .collect::<Vec<_>>();
4809                (path, offset_ranges)
4810            })
4811        })
4812        .collect::<Vec<_>>();
4813    ranges_by_path.sort_by_key(|(path, _)| path.clone());
4814
4815    assert_eq!(
4816        ranges_by_path,
4817        &[
4818            (PathBuf::from("dir-1/a"), vec![6..11]),
4819            (PathBuf::from("dir-1/c"), vec![2..7]),
4820            (PathBuf::from("dir-1/d"), vec![0..5, 24..29]),
4821            (PathBuf::from("dir-2/e"), vec![7..12]),
4822        ]
4823    );
4824}
4825
4826#[gpui::test(iterations = 10)]
4827async fn test_document_highlights(
4828    executor: BackgroundExecutor,
4829    cx_a: &mut TestAppContext,
4830    cx_b: &mut TestAppContext,
4831) {
4832    let mut server = TestServer::start(executor.clone()).await;
4833    let client_a = server.create_client(cx_a, "user_a").await;
4834    let client_b = server.create_client(cx_b, "user_b").await;
4835    server
4836        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
4837        .await;
4838    let active_call_a = cx_a.read(ActiveCall::global);
4839
4840    client_a
4841        .fs()
4842        .insert_tree(
4843            "/root-1",
4844            json!({
4845                "main.rs": "fn double(number: i32) -> i32 { number + number }",
4846            }),
4847        )
4848        .await;
4849
4850    // Set up a fake language server.
4851    let mut language = Language::new(
4852        LanguageConfig {
4853            name: "Rust".into(),
4854            path_suffixes: vec!["rs".to_string()],
4855            ..Default::default()
4856        },
4857        Some(tree_sitter_rust::language()),
4858    );
4859    let mut fake_language_servers = language.set_fake_lsp_adapter(Default::default()).await;
4860    client_a.language_registry().add(Arc::new(language));
4861
4862    let (project_a, worktree_id) = client_a.build_local_project("/root-1", cx_a).await;
4863    let project_id = active_call_a
4864        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
4865        .await
4866        .unwrap();
4867    let project_b = client_b.build_remote_project(project_id, cx_b).await;
4868
4869    // Open the file on client B.
4870    let open_b = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "main.rs"), cx));
4871    let buffer_b = cx_b.executor().spawn(open_b).await.unwrap();
4872
4873    // Request document highlights as the guest.
4874    let fake_language_server = fake_language_servers.next().await.unwrap();
4875    fake_language_server.handle_request::<lsp::request::DocumentHighlightRequest, _, _>(
4876        |params, _| async move {
4877            assert_eq!(
4878                params
4879                    .text_document_position_params
4880                    .text_document
4881                    .uri
4882                    .as_str(),
4883                "file:///root-1/main.rs"
4884            );
4885            assert_eq!(
4886                params.text_document_position_params.position,
4887                lsp::Position::new(0, 34)
4888            );
4889            Ok(Some(vec![
4890                lsp::DocumentHighlight {
4891                    kind: Some(lsp::DocumentHighlightKind::WRITE),
4892                    range: lsp::Range::new(lsp::Position::new(0, 10), lsp::Position::new(0, 16)),
4893                },
4894                lsp::DocumentHighlight {
4895                    kind: Some(lsp::DocumentHighlightKind::READ),
4896                    range: lsp::Range::new(lsp::Position::new(0, 32), lsp::Position::new(0, 38)),
4897                },
4898                lsp::DocumentHighlight {
4899                    kind: Some(lsp::DocumentHighlightKind::READ),
4900                    range: lsp::Range::new(lsp::Position::new(0, 41), lsp::Position::new(0, 47)),
4901                },
4902            ]))
4903        },
4904    );
4905
4906    let highlights = project_b
4907        .update(cx_b, |p, cx| p.document_highlights(&buffer_b, 34, cx))
4908        .await
4909        .unwrap();
4910
4911    buffer_b.read_with(cx_b, |buffer, _| {
4912        let snapshot = buffer.snapshot();
4913
4914        let highlights = highlights
4915            .into_iter()
4916            .map(|highlight| (highlight.kind, highlight.range.to_offset(&snapshot)))
4917            .collect::<Vec<_>>();
4918        assert_eq!(
4919            highlights,
4920            &[
4921                (lsp::DocumentHighlightKind::WRITE, 10..16),
4922                (lsp::DocumentHighlightKind::READ, 32..38),
4923                (lsp::DocumentHighlightKind::READ, 41..47)
4924            ]
4925        )
4926    });
4927}
4928
4929#[gpui::test(iterations = 10)]
4930async fn test_lsp_hover(
4931    executor: BackgroundExecutor,
4932    cx_a: &mut TestAppContext,
4933    cx_b: &mut TestAppContext,
4934) {
4935    let mut server = TestServer::start(executor.clone()).await;
4936    let client_a = server.create_client(cx_a, "user_a").await;
4937    let client_b = server.create_client(cx_b, "user_b").await;
4938    server
4939        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
4940        .await;
4941    let active_call_a = cx_a.read(ActiveCall::global);
4942
4943    client_a
4944        .fs()
4945        .insert_tree(
4946            "/root-1",
4947            json!({
4948                "main.rs": "use std::collections::HashMap;",
4949            }),
4950        )
4951        .await;
4952
4953    // Set up a fake language server.
4954    let mut language = Language::new(
4955        LanguageConfig {
4956            name: "Rust".into(),
4957            path_suffixes: vec!["rs".to_string()],
4958            ..Default::default()
4959        },
4960        Some(tree_sitter_rust::language()),
4961    );
4962    let mut fake_language_servers = language.set_fake_lsp_adapter(Default::default()).await;
4963    client_a.language_registry().add(Arc::new(language));
4964
4965    let (project_a, worktree_id) = client_a.build_local_project("/root-1", cx_a).await;
4966    let project_id = active_call_a
4967        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
4968        .await
4969        .unwrap();
4970    let project_b = client_b.build_remote_project(project_id, cx_b).await;
4971
4972    // Open the file as the guest
4973    let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "main.rs"), cx));
4974    let buffer_b = cx_b.executor().spawn(open_buffer).await.unwrap();
4975
4976    // Request hover information as the guest.
4977    let fake_language_server = fake_language_servers.next().await.unwrap();
4978    fake_language_server.handle_request::<lsp::request::HoverRequest, _, _>(
4979        |params, _| async move {
4980            assert_eq!(
4981                params
4982                    .text_document_position_params
4983                    .text_document
4984                    .uri
4985                    .as_str(),
4986                "file:///root-1/main.rs"
4987            );
4988            assert_eq!(
4989                params.text_document_position_params.position,
4990                lsp::Position::new(0, 22)
4991            );
4992            Ok(Some(lsp::Hover {
4993                contents: lsp::HoverContents::Array(vec![
4994                    lsp::MarkedString::String("Test hover content.".to_string()),
4995                    lsp::MarkedString::LanguageString(lsp::LanguageString {
4996                        language: "Rust".to_string(),
4997                        value: "let foo = 42;".to_string(),
4998                    }),
4999                ]),
5000                range: Some(lsp::Range::new(
5001                    lsp::Position::new(0, 22),
5002                    lsp::Position::new(0, 29),
5003                )),
5004            }))
5005        },
5006    );
5007
5008    let hover_info = project_b
5009        .update(cx_b, |p, cx| p.hover(&buffer_b, 22, cx))
5010        .await
5011        .unwrap()
5012        .unwrap();
5013
5014    buffer_b.read_with(cx_b, |buffer, _| {
5015        let snapshot = buffer.snapshot();
5016        assert_eq!(hover_info.range.unwrap().to_offset(&snapshot), 22..29);
5017        assert_eq!(
5018            hover_info.contents,
5019            vec![
5020                project::HoverBlock {
5021                    text: "Test hover content.".to_string(),
5022                    kind: HoverBlockKind::Markdown,
5023                },
5024                project::HoverBlock {
5025                    text: "let foo = 42;".to_string(),
5026                    kind: HoverBlockKind::Code {
5027                        language: "Rust".to_string()
5028                    },
5029                }
5030            ]
5031        );
5032    });
5033}
5034
5035#[gpui::test(iterations = 10)]
5036async fn test_project_symbols(
5037    executor: BackgroundExecutor,
5038    cx_a: &mut TestAppContext,
5039    cx_b: &mut TestAppContext,
5040) {
5041    let mut server = TestServer::start(executor.clone()).await;
5042    let client_a = server.create_client(cx_a, "user_a").await;
5043    let client_b = server.create_client(cx_b, "user_b").await;
5044    server
5045        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
5046        .await;
5047    let active_call_a = cx_a.read(ActiveCall::global);
5048
5049    // Set up a fake language server.
5050    let mut language = Language::new(
5051        LanguageConfig {
5052            name: "Rust".into(),
5053            path_suffixes: vec!["rs".to_string()],
5054            ..Default::default()
5055        },
5056        Some(tree_sitter_rust::language()),
5057    );
5058    let mut fake_language_servers = language.set_fake_lsp_adapter(Default::default()).await;
5059    client_a.language_registry().add(Arc::new(language));
5060
5061    client_a
5062        .fs()
5063        .insert_tree(
5064            "/code",
5065            json!({
5066                "crate-1": {
5067                    "one.rs": "const ONE: usize = 1;",
5068                },
5069                "crate-2": {
5070                    "two.rs": "const TWO: usize = 2; const THREE: usize = 3;",
5071                },
5072                "private": {
5073                    "passwords.txt": "the-password",
5074                }
5075            }),
5076        )
5077        .await;
5078    let (project_a, worktree_id) = client_a.build_local_project("/code/crate-1", cx_a).await;
5079    let project_id = active_call_a
5080        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
5081        .await
5082        .unwrap();
5083    let project_b = client_b.build_remote_project(project_id, cx_b).await;
5084
5085    // Cause the language server to start.
5086    let open_buffer_task =
5087        project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "one.rs"), cx));
5088    let _buffer = cx_b.executor().spawn(open_buffer_task).await.unwrap();
5089
5090    let fake_language_server = fake_language_servers.next().await.unwrap();
5091    fake_language_server.handle_request::<lsp::WorkspaceSymbolRequest, _, _>(|_, _| async move {
5092        Ok(Some(lsp::WorkspaceSymbolResponse::Flat(vec![
5093            #[allow(deprecated)]
5094            lsp::SymbolInformation {
5095                name: "TWO".into(),
5096                location: lsp::Location {
5097                    uri: lsp::Url::from_file_path("/code/crate-2/two.rs").unwrap(),
5098                    range: lsp::Range::new(lsp::Position::new(0, 6), lsp::Position::new(0, 9)),
5099                },
5100                kind: lsp::SymbolKind::CONSTANT,
5101                tags: None,
5102                container_name: None,
5103                deprecated: None,
5104            },
5105        ])))
5106    });
5107
5108    // Request the definition of a symbol as the guest.
5109    let symbols = project_b
5110        .update(cx_b, |p, cx| p.symbols("two", cx))
5111        .await
5112        .unwrap();
5113    assert_eq!(symbols.len(), 1);
5114    assert_eq!(symbols[0].name, "TWO");
5115
5116    // Open one of the returned symbols.
5117    let buffer_b_2 = project_b
5118        .update(cx_b, |project, cx| {
5119            project.open_buffer_for_symbol(&symbols[0], cx)
5120        })
5121        .await
5122        .unwrap();
5123
5124    buffer_b_2.read_with(cx_b, |buffer, cx| {
5125        assert_eq!(
5126            buffer.file().unwrap().full_path(cx),
5127            Path::new("/code/crate-2/two.rs")
5128        );
5129    });
5130
5131    // Attempt to craft a symbol and violate host's privacy by opening an arbitrary file.
5132    let mut fake_symbol = symbols[0].clone();
5133    fake_symbol.path.path = Path::new("/code/secrets").into();
5134    let error = project_b
5135        .update(cx_b, |project, cx| {
5136            project.open_buffer_for_symbol(&fake_symbol, cx)
5137        })
5138        .await
5139        .unwrap_err();
5140    assert!(error.to_string().contains("invalid symbol signature"));
5141}
5142
5143#[gpui::test(iterations = 10)]
5144async fn test_open_buffer_while_getting_definition_pointing_to_it(
5145    executor: BackgroundExecutor,
5146    cx_a: &mut TestAppContext,
5147    cx_b: &mut TestAppContext,
5148    mut rng: StdRng,
5149) {
5150    let mut server = TestServer::start(executor.clone()).await;
5151    let client_a = server.create_client(cx_a, "user_a").await;
5152    let client_b = server.create_client(cx_b, "user_b").await;
5153    server
5154        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
5155        .await;
5156    let active_call_a = cx_a.read(ActiveCall::global);
5157
5158    // Set up a fake language server.
5159    let mut language = Language::new(
5160        LanguageConfig {
5161            name: "Rust".into(),
5162            path_suffixes: vec!["rs".to_string()],
5163            ..Default::default()
5164        },
5165        Some(tree_sitter_rust::language()),
5166    );
5167    let mut fake_language_servers = language.set_fake_lsp_adapter(Default::default()).await;
5168    client_a.language_registry().add(Arc::new(language));
5169
5170    client_a
5171        .fs()
5172        .insert_tree(
5173            "/root",
5174            json!({
5175                "a.rs": "const ONE: usize = b::TWO;",
5176                "b.rs": "const TWO: usize = 2",
5177            }),
5178        )
5179        .await;
5180    let (project_a, worktree_id) = client_a.build_local_project("/root", cx_a).await;
5181    let project_id = active_call_a
5182        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
5183        .await
5184        .unwrap();
5185    let project_b = client_b.build_remote_project(project_id, cx_b).await;
5186
5187    let open_buffer_task = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx));
5188    let buffer_b1 = cx_b.executor().spawn(open_buffer_task).await.unwrap();
5189
5190    let fake_language_server = fake_language_servers.next().await.unwrap();
5191    fake_language_server.handle_request::<lsp::request::GotoDefinition, _, _>(|_, _| async move {
5192        Ok(Some(lsp::GotoDefinitionResponse::Scalar(
5193            lsp::Location::new(
5194                lsp::Url::from_file_path("/root/b.rs").unwrap(),
5195                lsp::Range::new(lsp::Position::new(0, 6), lsp::Position::new(0, 9)),
5196            ),
5197        )))
5198    });
5199
5200    let definitions;
5201    let buffer_b2;
5202    if rng.gen() {
5203        definitions = project_b.update(cx_b, |p, cx| p.definition(&buffer_b1, 23, cx));
5204        buffer_b2 = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "b.rs"), cx));
5205    } else {
5206        buffer_b2 = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "b.rs"), cx));
5207        definitions = project_b.update(cx_b, |p, cx| p.definition(&buffer_b1, 23, cx));
5208    }
5209
5210    let buffer_b2 = buffer_b2.await.unwrap();
5211    let definitions = definitions.await.unwrap();
5212    assert_eq!(definitions.len(), 1);
5213    assert_eq!(definitions[0].target.buffer, buffer_b2);
5214}
5215
5216#[gpui::test(iterations = 10)]
5217async fn test_contacts(
5218    executor: BackgroundExecutor,
5219    cx_a: &mut TestAppContext,
5220    cx_b: &mut TestAppContext,
5221    cx_c: &mut TestAppContext,
5222    cx_d: &mut TestAppContext,
5223) {
5224    let mut server = TestServer::start(executor.clone()).await;
5225    let client_a = server.create_client(cx_a, "user_a").await;
5226    let client_b = server.create_client(cx_b, "user_b").await;
5227    let client_c = server.create_client(cx_c, "user_c").await;
5228    let client_d = server.create_client(cx_d, "user_d").await;
5229    server
5230        .make_contacts(&mut [(&client_a, cx_a), (&client_b, cx_b), (&client_c, cx_c)])
5231        .await;
5232    let active_call_a = cx_a.read(ActiveCall::global);
5233    let active_call_b = cx_b.read(ActiveCall::global);
5234    let active_call_c = cx_c.read(ActiveCall::global);
5235    let _active_call_d = cx_d.read(ActiveCall::global);
5236
5237    executor.run_until_parked();
5238    assert_eq!(
5239        contacts(&client_a, cx_a),
5240        [
5241            ("user_b".to_string(), "online", "free"),
5242            ("user_c".to_string(), "online", "free")
5243        ]
5244    );
5245    assert_eq!(
5246        contacts(&client_b, cx_b),
5247        [
5248            ("user_a".to_string(), "online", "free"),
5249            ("user_c".to_string(), "online", "free")
5250        ]
5251    );
5252    assert_eq!(
5253        contacts(&client_c, cx_c),
5254        [
5255            ("user_a".to_string(), "online", "free"),
5256            ("user_b".to_string(), "online", "free")
5257        ]
5258    );
5259    assert_eq!(contacts(&client_d, cx_d), []);
5260
5261    server.disconnect_client(client_c.peer_id().unwrap());
5262    server.forbid_connections();
5263    executor.advance_clock(RECEIVE_TIMEOUT + RECONNECT_TIMEOUT);
5264    assert_eq!(
5265        contacts(&client_a, cx_a),
5266        [
5267            ("user_b".to_string(), "online", "free"),
5268            ("user_c".to_string(), "offline", "free")
5269        ]
5270    );
5271    assert_eq!(
5272        contacts(&client_b, cx_b),
5273        [
5274            ("user_a".to_string(), "online", "free"),
5275            ("user_c".to_string(), "offline", "free")
5276        ]
5277    );
5278    assert_eq!(contacts(&client_c, cx_c), []);
5279    assert_eq!(contacts(&client_d, cx_d), []);
5280
5281    server.allow_connections();
5282    client_c
5283        .authenticate_and_connect(false, &cx_c.to_async())
5284        .await
5285        .unwrap();
5286
5287    executor.run_until_parked();
5288    assert_eq!(
5289        contacts(&client_a, cx_a),
5290        [
5291            ("user_b".to_string(), "online", "free"),
5292            ("user_c".to_string(), "online", "free")
5293        ]
5294    );
5295    assert_eq!(
5296        contacts(&client_b, cx_b),
5297        [
5298            ("user_a".to_string(), "online", "free"),
5299            ("user_c".to_string(), "online", "free")
5300        ]
5301    );
5302    assert_eq!(
5303        contacts(&client_c, cx_c),
5304        [
5305            ("user_a".to_string(), "online", "free"),
5306            ("user_b".to_string(), "online", "free")
5307        ]
5308    );
5309    assert_eq!(contacts(&client_d, cx_d), []);
5310
5311    active_call_a
5312        .update(cx_a, |call, cx| {
5313            call.invite(client_b.user_id().unwrap(), None, cx)
5314        })
5315        .await
5316        .unwrap();
5317    executor.run_until_parked();
5318    assert_eq!(
5319        contacts(&client_a, cx_a),
5320        [
5321            ("user_b".to_string(), "online", "busy"),
5322            ("user_c".to_string(), "online", "free")
5323        ]
5324    );
5325    assert_eq!(
5326        contacts(&client_b, cx_b),
5327        [
5328            ("user_a".to_string(), "online", "busy"),
5329            ("user_c".to_string(), "online", "free")
5330        ]
5331    );
5332    assert_eq!(
5333        contacts(&client_c, cx_c),
5334        [
5335            ("user_a".to_string(), "online", "busy"),
5336            ("user_b".to_string(), "online", "busy")
5337        ]
5338    );
5339    assert_eq!(contacts(&client_d, cx_d), []);
5340
5341    // Client B and client D become contacts while client B is being called.
5342    server
5343        .make_contacts(&mut [(&client_b, cx_b), (&client_d, cx_d)])
5344        .await;
5345    executor.run_until_parked();
5346    assert_eq!(
5347        contacts(&client_a, cx_a),
5348        [
5349            ("user_b".to_string(), "online", "busy"),
5350            ("user_c".to_string(), "online", "free")
5351        ]
5352    );
5353    assert_eq!(
5354        contacts(&client_b, cx_b),
5355        [
5356            ("user_a".to_string(), "online", "busy"),
5357            ("user_c".to_string(), "online", "free"),
5358            ("user_d".to_string(), "online", "free"),
5359        ]
5360    );
5361    assert_eq!(
5362        contacts(&client_c, cx_c),
5363        [
5364            ("user_a".to_string(), "online", "busy"),
5365            ("user_b".to_string(), "online", "busy")
5366        ]
5367    );
5368    assert_eq!(
5369        contacts(&client_d, cx_d),
5370        [("user_b".to_string(), "online", "busy")]
5371    );
5372
5373    active_call_b.update(cx_b, |call, cx| call.decline_incoming(cx).unwrap());
5374    executor.run_until_parked();
5375    assert_eq!(
5376        contacts(&client_a, cx_a),
5377        [
5378            ("user_b".to_string(), "online", "free"),
5379            ("user_c".to_string(), "online", "free")
5380        ]
5381    );
5382    assert_eq!(
5383        contacts(&client_b, cx_b),
5384        [
5385            ("user_a".to_string(), "online", "free"),
5386            ("user_c".to_string(), "online", "free"),
5387            ("user_d".to_string(), "online", "free")
5388        ]
5389    );
5390    assert_eq!(
5391        contacts(&client_c, cx_c),
5392        [
5393            ("user_a".to_string(), "online", "free"),
5394            ("user_b".to_string(), "online", "free")
5395        ]
5396    );
5397    assert_eq!(
5398        contacts(&client_d, cx_d),
5399        [("user_b".to_string(), "online", "free")]
5400    );
5401
5402    active_call_c
5403        .update(cx_c, |call, cx| {
5404            call.invite(client_a.user_id().unwrap(), None, cx)
5405        })
5406        .await
5407        .unwrap();
5408    executor.run_until_parked();
5409    assert_eq!(
5410        contacts(&client_a, cx_a),
5411        [
5412            ("user_b".to_string(), "online", "free"),
5413            ("user_c".to_string(), "online", "busy")
5414        ]
5415    );
5416    assert_eq!(
5417        contacts(&client_b, cx_b),
5418        [
5419            ("user_a".to_string(), "online", "busy"),
5420            ("user_c".to_string(), "online", "busy"),
5421            ("user_d".to_string(), "online", "free")
5422        ]
5423    );
5424    assert_eq!(
5425        contacts(&client_c, cx_c),
5426        [
5427            ("user_a".to_string(), "online", "busy"),
5428            ("user_b".to_string(), "online", "free")
5429        ]
5430    );
5431    assert_eq!(
5432        contacts(&client_d, cx_d),
5433        [("user_b".to_string(), "online", "free")]
5434    );
5435
5436    active_call_a
5437        .update(cx_a, |call, cx| call.accept_incoming(cx))
5438        .await
5439        .unwrap();
5440    executor.run_until_parked();
5441    assert_eq!(
5442        contacts(&client_a, cx_a),
5443        [
5444            ("user_b".to_string(), "online", "free"),
5445            ("user_c".to_string(), "online", "busy")
5446        ]
5447    );
5448    assert_eq!(
5449        contacts(&client_b, cx_b),
5450        [
5451            ("user_a".to_string(), "online", "busy"),
5452            ("user_c".to_string(), "online", "busy"),
5453            ("user_d".to_string(), "online", "free")
5454        ]
5455    );
5456    assert_eq!(
5457        contacts(&client_c, cx_c),
5458        [
5459            ("user_a".to_string(), "online", "busy"),
5460            ("user_b".to_string(), "online", "free")
5461        ]
5462    );
5463    assert_eq!(
5464        contacts(&client_d, cx_d),
5465        [("user_b".to_string(), "online", "free")]
5466    );
5467
5468    active_call_a
5469        .update(cx_a, |call, cx| {
5470            call.invite(client_b.user_id().unwrap(), None, cx)
5471        })
5472        .await
5473        .unwrap();
5474    executor.run_until_parked();
5475    assert_eq!(
5476        contacts(&client_a, cx_a),
5477        [
5478            ("user_b".to_string(), "online", "busy"),
5479            ("user_c".to_string(), "online", "busy")
5480        ]
5481    );
5482    assert_eq!(
5483        contacts(&client_b, cx_b),
5484        [
5485            ("user_a".to_string(), "online", "busy"),
5486            ("user_c".to_string(), "online", "busy"),
5487            ("user_d".to_string(), "online", "free")
5488        ]
5489    );
5490    assert_eq!(
5491        contacts(&client_c, cx_c),
5492        [
5493            ("user_a".to_string(), "online", "busy"),
5494            ("user_b".to_string(), "online", "busy")
5495        ]
5496    );
5497    assert_eq!(
5498        contacts(&client_d, cx_d),
5499        [("user_b".to_string(), "online", "busy")]
5500    );
5501
5502    active_call_a
5503        .update(cx_a, |call, cx| call.hang_up(cx))
5504        .await
5505        .unwrap();
5506    executor.run_until_parked();
5507    assert_eq!(
5508        contacts(&client_a, cx_a),
5509        [
5510            ("user_b".to_string(), "online", "free"),
5511            ("user_c".to_string(), "online", "free")
5512        ]
5513    );
5514    assert_eq!(
5515        contacts(&client_b, cx_b),
5516        [
5517            ("user_a".to_string(), "online", "free"),
5518            ("user_c".to_string(), "online", "free"),
5519            ("user_d".to_string(), "online", "free")
5520        ]
5521    );
5522    assert_eq!(
5523        contacts(&client_c, cx_c),
5524        [
5525            ("user_a".to_string(), "online", "free"),
5526            ("user_b".to_string(), "online", "free")
5527        ]
5528    );
5529    assert_eq!(
5530        contacts(&client_d, cx_d),
5531        [("user_b".to_string(), "online", "free")]
5532    );
5533
5534    active_call_a
5535        .update(cx_a, |call, cx| {
5536            call.invite(client_b.user_id().unwrap(), None, cx)
5537        })
5538        .await
5539        .unwrap();
5540    executor.run_until_parked();
5541    assert_eq!(
5542        contacts(&client_a, cx_a),
5543        [
5544            ("user_b".to_string(), "online", "busy"),
5545            ("user_c".to_string(), "online", "free")
5546        ]
5547    );
5548    assert_eq!(
5549        contacts(&client_b, cx_b),
5550        [
5551            ("user_a".to_string(), "online", "busy"),
5552            ("user_c".to_string(), "online", "free"),
5553            ("user_d".to_string(), "online", "free")
5554        ]
5555    );
5556    assert_eq!(
5557        contacts(&client_c, cx_c),
5558        [
5559            ("user_a".to_string(), "online", "busy"),
5560            ("user_b".to_string(), "online", "busy")
5561        ]
5562    );
5563    assert_eq!(
5564        contacts(&client_d, cx_d),
5565        [("user_b".to_string(), "online", "busy")]
5566    );
5567
5568    server.forbid_connections();
5569    server.disconnect_client(client_a.peer_id().unwrap());
5570    executor.advance_clock(RECEIVE_TIMEOUT + RECONNECT_TIMEOUT);
5571    assert_eq!(contacts(&client_a, cx_a), []);
5572    assert_eq!(
5573        contacts(&client_b, cx_b),
5574        [
5575            ("user_a".to_string(), "offline", "free"),
5576            ("user_c".to_string(), "online", "free"),
5577            ("user_d".to_string(), "online", "free")
5578        ]
5579    );
5580    assert_eq!(
5581        contacts(&client_c, cx_c),
5582        [
5583            ("user_a".to_string(), "offline", "free"),
5584            ("user_b".to_string(), "online", "free")
5585        ]
5586    );
5587    assert_eq!(
5588        contacts(&client_d, cx_d),
5589        [("user_b".to_string(), "online", "free")]
5590    );
5591
5592    // Test removing a contact
5593    client_b
5594        .user_store()
5595        .update(cx_b, |store, cx| {
5596            store.remove_contact(client_c.user_id().unwrap(), cx)
5597        })
5598        .await
5599        .unwrap();
5600    executor.run_until_parked();
5601    assert_eq!(
5602        contacts(&client_b, cx_b),
5603        [
5604            ("user_a".to_string(), "offline", "free"),
5605            ("user_d".to_string(), "online", "free")
5606        ]
5607    );
5608    assert_eq!(
5609        contacts(&client_c, cx_c),
5610        [("user_a".to_string(), "offline", "free"),]
5611    );
5612
5613    fn contacts(
5614        client: &TestClient,
5615        cx: &TestAppContext,
5616    ) -> Vec<(String, &'static str, &'static str)> {
5617        client.user_store().read_with(cx, |store, _| {
5618            store
5619                .contacts()
5620                .iter()
5621                .map(|contact| {
5622                    (
5623                        contact.user.github_login.clone(),
5624                        if contact.online { "online" } else { "offline" },
5625                        if contact.busy { "busy" } else { "free" },
5626                    )
5627                })
5628                .collect()
5629        })
5630    }
5631}
5632
5633#[gpui::test(iterations = 10)]
5634async fn test_contact_requests(
5635    executor: BackgroundExecutor,
5636    cx_a: &mut TestAppContext,
5637    cx_a2: &mut TestAppContext,
5638    cx_b: &mut TestAppContext,
5639    cx_b2: &mut TestAppContext,
5640    cx_c: &mut TestAppContext,
5641    cx_c2: &mut TestAppContext,
5642) {
5643    // Connect to a server as 3 clients.
5644    let mut server = TestServer::start(executor.clone()).await;
5645    let client_a = server.create_client(cx_a, "user_a").await;
5646    let client_a2 = server.create_client(cx_a2, "user_a").await;
5647    let client_b = server.create_client(cx_b, "user_b").await;
5648    let client_b2 = server.create_client(cx_b2, "user_b").await;
5649    let client_c = server.create_client(cx_c, "user_c").await;
5650    let client_c2 = server.create_client(cx_c2, "user_c").await;
5651
5652    assert_eq!(client_a.user_id().unwrap(), client_a2.user_id().unwrap());
5653    assert_eq!(client_b.user_id().unwrap(), client_b2.user_id().unwrap());
5654    assert_eq!(client_c.user_id().unwrap(), client_c2.user_id().unwrap());
5655
5656    // User A and User C request that user B become their contact.
5657    client_a
5658        .user_store()
5659        .update(cx_a, |store, cx| {
5660            store.request_contact(client_b.user_id().unwrap(), cx)
5661        })
5662        .await
5663        .unwrap();
5664    client_c
5665        .user_store()
5666        .update(cx_c, |store, cx| {
5667            store.request_contact(client_b.user_id().unwrap(), cx)
5668        })
5669        .await
5670        .unwrap();
5671    executor.run_until_parked();
5672
5673    // All users see the pending request appear in all their clients.
5674    assert_eq!(
5675        client_a.summarize_contacts(cx_a).outgoing_requests,
5676        &["user_b"]
5677    );
5678    assert_eq!(
5679        client_a2.summarize_contacts(cx_a2).outgoing_requests,
5680        &["user_b"]
5681    );
5682    assert_eq!(
5683        client_b.summarize_contacts(cx_b).incoming_requests,
5684        &["user_a", "user_c"]
5685    );
5686    assert_eq!(
5687        client_b2.summarize_contacts(cx_b2).incoming_requests,
5688        &["user_a", "user_c"]
5689    );
5690    assert_eq!(
5691        client_c.summarize_contacts(cx_c).outgoing_requests,
5692        &["user_b"]
5693    );
5694    assert_eq!(
5695        client_c2.summarize_contacts(cx_c2).outgoing_requests,
5696        &["user_b"]
5697    );
5698
5699    // Contact requests are present upon connecting (tested here via disconnect/reconnect)
5700    disconnect_and_reconnect(&client_a, cx_a).await;
5701    disconnect_and_reconnect(&client_b, cx_b).await;
5702    disconnect_and_reconnect(&client_c, cx_c).await;
5703    executor.run_until_parked();
5704    assert_eq!(
5705        client_a.summarize_contacts(cx_a).outgoing_requests,
5706        &["user_b"]
5707    );
5708    assert_eq!(
5709        client_b.summarize_contacts(cx_b).incoming_requests,
5710        &["user_a", "user_c"]
5711    );
5712    assert_eq!(
5713        client_c.summarize_contacts(cx_c).outgoing_requests,
5714        &["user_b"]
5715    );
5716
5717    // User B accepts the request from user A.
5718    client_b
5719        .user_store()
5720        .update(cx_b, |store, cx| {
5721            store.respond_to_contact_request(client_a.user_id().unwrap(), true, cx)
5722        })
5723        .await
5724        .unwrap();
5725
5726    executor.run_until_parked();
5727
5728    // User B sees user A as their contact now in all client, and the incoming request from them is removed.
5729    let contacts_b = client_b.summarize_contacts(cx_b);
5730    assert_eq!(contacts_b.current, &["user_a"]);
5731    assert_eq!(contacts_b.incoming_requests, &["user_c"]);
5732    let contacts_b2 = client_b2.summarize_contacts(cx_b2);
5733    assert_eq!(contacts_b2.current, &["user_a"]);
5734    assert_eq!(contacts_b2.incoming_requests, &["user_c"]);
5735
5736    // User A sees user B as their contact now in all clients, and the outgoing request to them is removed.
5737    let contacts_a = client_a.summarize_contacts(cx_a);
5738    assert_eq!(contacts_a.current, &["user_b"]);
5739    assert!(contacts_a.outgoing_requests.is_empty());
5740    let contacts_a2 = client_a2.summarize_contacts(cx_a2);
5741    assert_eq!(contacts_a2.current, &["user_b"]);
5742    assert!(contacts_a2.outgoing_requests.is_empty());
5743
5744    // Contacts are present upon connecting (tested here via disconnect/reconnect)
5745    disconnect_and_reconnect(&client_a, cx_a).await;
5746    disconnect_and_reconnect(&client_b, cx_b).await;
5747    disconnect_and_reconnect(&client_c, cx_c).await;
5748    executor.run_until_parked();
5749    assert_eq!(client_a.summarize_contacts(cx_a).current, &["user_b"]);
5750    assert_eq!(client_b.summarize_contacts(cx_b).current, &["user_a"]);
5751    assert_eq!(
5752        client_b.summarize_contacts(cx_b).incoming_requests,
5753        &["user_c"]
5754    );
5755    assert!(client_c.summarize_contacts(cx_c).current.is_empty());
5756    assert_eq!(
5757        client_c.summarize_contacts(cx_c).outgoing_requests,
5758        &["user_b"]
5759    );
5760
5761    // User B rejects the request from user C.
5762    client_b
5763        .user_store()
5764        .update(cx_b, |store, cx| {
5765            store.respond_to_contact_request(client_c.user_id().unwrap(), false, cx)
5766        })
5767        .await
5768        .unwrap();
5769
5770    executor.run_until_parked();
5771
5772    // User B doesn't see user C as their contact, and the incoming request from them is removed.
5773    let contacts_b = client_b.summarize_contacts(cx_b);
5774    assert_eq!(contacts_b.current, &["user_a"]);
5775    assert!(contacts_b.incoming_requests.is_empty());
5776    let contacts_b2 = client_b2.summarize_contacts(cx_b2);
5777    assert_eq!(contacts_b2.current, &["user_a"]);
5778    assert!(contacts_b2.incoming_requests.is_empty());
5779
5780    // User C doesn't see user B as their contact, and the outgoing request to them is removed.
5781    let contacts_c = client_c.summarize_contacts(cx_c);
5782    assert!(contacts_c.current.is_empty());
5783    assert!(contacts_c.outgoing_requests.is_empty());
5784    let contacts_c2 = client_c2.summarize_contacts(cx_c2);
5785    assert!(contacts_c2.current.is_empty());
5786    assert!(contacts_c2.outgoing_requests.is_empty());
5787
5788    // Incoming/outgoing requests are not present upon connecting (tested here via disconnect/reconnect)
5789    disconnect_and_reconnect(&client_a, cx_a).await;
5790    disconnect_and_reconnect(&client_b, cx_b).await;
5791    disconnect_and_reconnect(&client_c, cx_c).await;
5792    executor.run_until_parked();
5793    assert_eq!(client_a.summarize_contacts(cx_a).current, &["user_b"]);
5794    assert_eq!(client_b.summarize_contacts(cx_b).current, &["user_a"]);
5795    assert!(client_b
5796        .summarize_contacts(cx_b)
5797        .incoming_requests
5798        .is_empty());
5799    assert!(client_c.summarize_contacts(cx_c).current.is_empty());
5800    assert!(client_c
5801        .summarize_contacts(cx_c)
5802        .outgoing_requests
5803        .is_empty());
5804
5805    async fn disconnect_and_reconnect(client: &TestClient, cx: &mut TestAppContext) {
5806        client.disconnect(&cx.to_async());
5807        client.clear_contacts(cx).await;
5808        client
5809            .authenticate_and_connect(false, &cx.to_async())
5810            .await
5811            .unwrap();
5812    }
5813}
5814
5815#[gpui::test(iterations = 10)]
5816async fn test_join_call_after_screen_was_shared(
5817    executor: BackgroundExecutor,
5818    cx_a: &mut TestAppContext,
5819    cx_b: &mut TestAppContext,
5820) {
5821    let mut server = TestServer::start(executor.clone()).await;
5822
5823    let client_a = server.create_client(cx_a, "user_a").await;
5824    let client_b = server.create_client(cx_b, "user_b").await;
5825    server
5826        .make_contacts(&mut [(&client_a, cx_a), (&client_b, cx_b)])
5827        .await;
5828
5829    let active_call_a = cx_a.read(ActiveCall::global);
5830    let active_call_b = cx_b.read(ActiveCall::global);
5831
5832    // Call users B and C from client A.
5833    active_call_a
5834        .update(cx_a, |call, cx| {
5835            call.invite(client_b.user_id().unwrap(), None, cx)
5836        })
5837        .await
5838        .unwrap();
5839
5840    let room_a = active_call_a.read_with(cx_a, |call, _| call.room().unwrap().clone());
5841    executor.run_until_parked();
5842    assert_eq!(
5843        room_participants(&room_a, cx_a),
5844        RoomParticipants {
5845            remote: Default::default(),
5846            pending: vec!["user_b".to_string()]
5847        }
5848    );
5849
5850    // User B receives the call.
5851
5852    let mut incoming_call_b = active_call_b.read_with(cx_b, |call, _| call.incoming());
5853    let call_b = incoming_call_b.next().await.unwrap().unwrap();
5854    assert_eq!(call_b.calling_user.github_login, "user_a");
5855
5856    // User A shares their screen
5857    let display = MacOSDisplay::new();
5858    active_call_a
5859        .update(cx_a, |call, cx| {
5860            call.room().unwrap().update(cx, |room, cx| {
5861                room.set_display_sources(vec![display.clone()]);
5862                room.share_screen(cx)
5863            })
5864        })
5865        .await
5866        .unwrap();
5867
5868    client_b.user_store().update(cx_b, |user_store, _| {
5869        user_store.clear_cache();
5870    });
5871
5872    // User B joins the room
5873    active_call_b
5874        .update(cx_b, |call, cx| call.accept_incoming(cx))
5875        .await
5876        .unwrap();
5877
5878    let room_b = active_call_b.read_with(cx_b, |call, _| call.room().unwrap().clone());
5879    assert!(incoming_call_b.next().await.unwrap().is_none());
5880
5881    executor.run_until_parked();
5882    assert_eq!(
5883        room_participants(&room_a, cx_a),
5884        RoomParticipants {
5885            remote: vec!["user_b".to_string()],
5886            pending: vec![],
5887        }
5888    );
5889    assert_eq!(
5890        room_participants(&room_b, cx_b),
5891        RoomParticipants {
5892            remote: vec!["user_a".to_string()],
5893            pending: vec![],
5894        }
5895    );
5896
5897    // Ensure User B sees User A's screenshare.
5898
5899    room_b.read_with(cx_b, |room, _| {
5900        assert_eq!(
5901            room.remote_participants()
5902                .get(&client_a.user_id().unwrap())
5903                .unwrap()
5904                .video_tracks
5905                .len(),
5906            1
5907        );
5908    });
5909}
5910
5911#[gpui::test]
5912async fn test_right_click_menu_behind_collab_panel(cx: &mut TestAppContext) {
5913    let mut server = TestServer::start(cx.executor().clone()).await;
5914    let client_a = server.create_client(cx, "user_a").await;
5915    let (_workspace_a, cx) = client_a.build_test_workspace(cx).await;
5916
5917    cx.simulate_resize(size(px(300.), px(300.)));
5918
5919    cx.simulate_keystrokes("cmd-n cmd-n cmd-n");
5920    cx.update(|cx| cx.refresh());
5921
5922    let tab_bounds = cx.debug_bounds("TAB-2").unwrap();
5923    let new_tab_button_bounds = cx.debug_bounds("ICON-Plus").unwrap();
5924
5925    assert!(
5926        tab_bounds.intersects(&new_tab_button_bounds),
5927        "Tab should overlap with the new tab button, if this is failing check if there's been a redesign!"
5928    );
5929
5930    cx.simulate_event(MouseDownEvent {
5931        button: MouseButton::Right,
5932        position: new_tab_button_bounds.center(),
5933        modifiers: Modifiers::default(),
5934        click_count: 1,
5935    });
5936
5937    // regression test that the right click menu for tabs does not open.
5938    assert!(cx.debug_bounds("MENU_ITEM-Close").is_none());
5939
5940    let tab_bounds = cx.debug_bounds("TAB-1").unwrap();
5941    cx.simulate_event(MouseDownEvent {
5942        button: MouseButton::Right,
5943        position: tab_bounds.center(),
5944        modifiers: Modifiers::default(),
5945        click_count: 1,
5946    });
5947    assert!(cx.debug_bounds("MENU_ITEM-Close").is_some());
5948}
5949
5950#[gpui::test]
5951async fn test_cmd_k_left(cx: &mut TestAppContext) {
5952    let client = TestServer::start1(cx).await;
5953    let (workspace, cx) = client.build_test_workspace(cx).await;
5954
5955    cx.simulate_keystrokes("cmd-n");
5956    workspace.update(cx, |workspace, cx| {
5957        assert!(workspace.items(cx).collect::<Vec<_>>().len() == 1);
5958    });
5959    cx.simulate_keystrokes("cmd-k left");
5960    workspace.update(cx, |workspace, cx| {
5961        assert!(workspace.items(cx).collect::<Vec<_>>().len() == 2);
5962    });
5963    cx.simulate_keystrokes("cmd-k");
5964    // sleep for longer than the timeout in keyboard shortcut handling
5965    // to verify that it doesn't fire in this case.
5966    cx.executor().advance_clock(Duration::from_secs(2));
5967    cx.simulate_keystrokes("left");
5968    workspace.update(cx, |workspace, cx| {
5969        assert!(workspace.items(cx).collect::<Vec<_>>().len() == 3);
5970    });
5971}