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