1use crate::{
   2    db::{self, NewUserParams, UserId},
   3    rpc::{CLEANUP_TIMEOUT, RECONNECT_TIMEOUT},
   4    tests::{TestClient, TestServer},
   5};
   6use anyhow::{anyhow, Result};
   7use call::ActiveCall;
   8use client::RECEIVE_TIMEOUT;
   9use collections::BTreeMap;
  10use editor::Bias;
  11use fs::{FakeFs, Fs as _};
  12use futures::StreamExt as _;
  13use gpui::{executor::Deterministic, ModelHandle, Task, TestAppContext};
  14use language::{range_to_lsp, FakeLspAdapter, Language, LanguageConfig, PointUtf16};
  15use lsp::FakeLanguageServer;
  16use parking_lot::Mutex;
  17use project::{search::SearchQuery, Project, ProjectPath};
  18use rand::{
  19    distributions::{Alphanumeric, DistString},
  20    prelude::*,
  21};
  22use serde::{Deserialize, Serialize};
  23use settings::Settings;
  24use std::{
  25    env,
  26    ops::Range,
  27    path::{Path, PathBuf},
  28    rc::Rc,
  29    sync::{
  30        atomic::{AtomicBool, Ordering::SeqCst},
  31        Arc,
  32    },
  33};
  34use util::ResultExt;
  35
  36lazy_static::lazy_static! {
  37    static ref PLAN_LOAD_PATH: Option<PathBuf> = path_env_var("LOAD_PLAN");
  38    static ref PLAN_SAVE_PATH: Option<PathBuf> = path_env_var("SAVE_PLAN");
  39    static ref LOADED_PLAN_JSON: Mutex<Option<Vec<u8>>> = Default::default();
  40    static ref PLAN: Mutex<Option<Arc<Mutex<TestPlan>>>> = Default::default();
  41}
  42
  43#[gpui::test(iterations = 100, on_failure = "on_failure")]
  44async fn test_random_collaboration(
  45    cx: &mut TestAppContext,
  46    deterministic: Arc<Deterministic>,
  47    rng: StdRng,
  48) {
  49    deterministic.forbid_parking();
  50
  51    let max_peers = env::var("MAX_PEERS")
  52        .map(|i| i.parse().expect("invalid `MAX_PEERS` variable"))
  53        .unwrap_or(3);
  54    let max_operations = env::var("OPERATIONS")
  55        .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
  56        .unwrap_or(10);
  57
  58    let mut server = TestServer::start(&deterministic).await;
  59    let db = server.app_state.db.clone();
  60
  61    let mut users = Vec::new();
  62    for ix in 0..max_peers {
  63        let username = format!("user-{}", ix + 1);
  64        let user_id = db
  65            .create_user(
  66                &format!("{username}@example.com"),
  67                false,
  68                NewUserParams {
  69                    github_login: username.clone(),
  70                    github_user_id: (ix + 1) as i32,
  71                    invite_count: 0,
  72                },
  73            )
  74            .await
  75            .unwrap()
  76            .user_id;
  77        users.push(UserTestPlan {
  78            user_id,
  79            username,
  80            online: false,
  81            next_root_id: 0,
  82            operation_ix: 0,
  83        });
  84    }
  85
  86    for (ix, user_a) in users.iter().enumerate() {
  87        for user_b in &users[ix + 1..] {
  88            server
  89                .app_state
  90                .db
  91                .send_contact_request(user_a.user_id, user_b.user_id)
  92                .await
  93                .unwrap();
  94            server
  95                .app_state
  96                .db
  97                .respond_to_contact_request(user_b.user_id, user_a.user_id, true)
  98                .await
  99                .unwrap();
 100        }
 101    }
 102
 103    let plan = Arc::new(Mutex::new(TestPlan::new(rng, users, max_operations)));
 104
 105    if let Some(path) = &*PLAN_LOAD_PATH {
 106        let json = LOADED_PLAN_JSON
 107            .lock()
 108            .get_or_insert_with(|| {
 109                eprintln!("loaded test plan from path {:?}", path);
 110                std::fs::read(path).unwrap()
 111            })
 112            .clone();
 113        plan.lock().deserialize(json);
 114    }
 115
 116    PLAN.lock().replace(plan.clone());
 117
 118    let mut clients = Vec::new();
 119    let mut client_tasks = Vec::new();
 120    let mut operation_channels = Vec::new();
 121
 122    loop {
 123        let Some((next_operation, applied)) = plan.lock().next_server_operation(&clients) else { break };
 124        applied.store(true, SeqCst);
 125        let did_apply = apply_server_operation(
 126            deterministic.clone(),
 127            &mut server,
 128            &mut clients,
 129            &mut client_tasks,
 130            &mut operation_channels,
 131            plan.clone(),
 132            next_operation,
 133            cx,
 134        )
 135        .await;
 136        if !did_apply {
 137            applied.store(false, SeqCst);
 138        }
 139    }
 140
 141    drop(operation_channels);
 142    deterministic.start_waiting();
 143    futures::future::join_all(client_tasks).await;
 144    deterministic.finish_waiting();
 145    deterministic.run_until_parked();
 146
 147    check_consistency_between_clients(&clients);
 148
 149    for (client, mut cx) in clients {
 150        cx.update(|cx| {
 151            cx.clear_globals();
 152            cx.set_global(Settings::test(cx));
 153            drop(client);
 154        });
 155    }
 156
 157    deterministic.run_until_parked();
 158}
 159
 160fn on_failure() {
 161    if let Some(plan) = PLAN.lock().clone() {
 162        if let Some(path) = &*PLAN_SAVE_PATH {
 163            eprintln!("saved test plan to path {:?}", path);
 164            std::fs::write(path, plan.lock().serialize()).unwrap();
 165        }
 166    }
 167}
 168
 169async fn apply_server_operation(
 170    deterministic: Arc<Deterministic>,
 171    server: &mut TestServer,
 172    clients: &mut Vec<(Rc<TestClient>, TestAppContext)>,
 173    client_tasks: &mut Vec<Task<()>>,
 174    operation_channels: &mut Vec<futures::channel::mpsc::UnboundedSender<usize>>,
 175    plan: Arc<Mutex<TestPlan>>,
 176    operation: Operation,
 177    cx: &mut TestAppContext,
 178) -> bool {
 179    match operation {
 180        Operation::AddConnection { user_id } => {
 181            let username;
 182            {
 183                let mut plan = plan.lock();
 184                let mut user = plan.user(user_id);
 185                if user.online {
 186                    return false;
 187                }
 188                user.online = true;
 189                username = user.username.clone();
 190            };
 191            log::info!("Adding new connection for {}", username);
 192            let next_entity_id = (user_id.0 * 10_000) as usize;
 193            let mut client_cx = TestAppContext::new(
 194                cx.foreground_platform(),
 195                cx.platform(),
 196                deterministic.build_foreground(user_id.0 as usize),
 197                deterministic.build_background(),
 198                cx.font_cache(),
 199                cx.leak_detector(),
 200                next_entity_id,
 201                cx.function_name.clone(),
 202            );
 203
 204            let (operation_tx, operation_rx) = futures::channel::mpsc::unbounded();
 205            let client = Rc::new(server.create_client(&mut client_cx, &username).await);
 206            operation_channels.push(operation_tx);
 207            clients.push((client.clone(), client_cx.clone()));
 208            client_tasks.push(client_cx.foreground().spawn(simulate_client(
 209                client,
 210                operation_rx,
 211                plan.clone(),
 212                client_cx,
 213            )));
 214
 215            log::info!("Added connection for {}", username);
 216        }
 217
 218        Operation::RemoveConnection {
 219            user_id: removed_user_id,
 220        } => {
 221            log::info!("Simulating full disconnection of user {}", removed_user_id);
 222            let client_ix = clients
 223                .iter()
 224                .position(|(client, cx)| client.current_user_id(cx) == removed_user_id);
 225            let Some(client_ix) = client_ix else { return false };
 226            let user_connection_ids = server
 227                .connection_pool
 228                .lock()
 229                .user_connection_ids(removed_user_id)
 230                .collect::<Vec<_>>();
 231            assert_eq!(user_connection_ids.len(), 1);
 232            let removed_peer_id = user_connection_ids[0].into();
 233            let (client, mut client_cx) = clients.remove(client_ix);
 234            let client_task = client_tasks.remove(client_ix);
 235            operation_channels.remove(client_ix);
 236            server.forbid_connections();
 237            server.disconnect_client(removed_peer_id);
 238            deterministic.advance_clock(RECEIVE_TIMEOUT + RECONNECT_TIMEOUT);
 239            deterministic.start_waiting();
 240            log::info!("Waiting for user {} to exit...", removed_user_id);
 241            client_task.await;
 242            deterministic.finish_waiting();
 243            server.allow_connections();
 244
 245            for project in client.remote_projects().iter() {
 246                project.read_with(&client_cx, |project, _| {
 247                    assert!(
 248                        project.is_read_only(),
 249                        "project {:?} should be read only",
 250                        project.remote_id()
 251                    )
 252                });
 253            }
 254
 255            for (client, cx) in clients {
 256                let contacts = server
 257                    .app_state
 258                    .db
 259                    .get_contacts(client.current_user_id(cx))
 260                    .await
 261                    .unwrap();
 262                let pool = server.connection_pool.lock();
 263                for contact in contacts {
 264                    if let db::Contact::Accepted { user_id, busy, .. } = contact {
 265                        if user_id == removed_user_id {
 266                            assert!(!pool.is_user_online(user_id));
 267                            assert!(!busy);
 268                        }
 269                    }
 270                }
 271            }
 272
 273            log::info!("{} removed", client.username);
 274            plan.lock().user(removed_user_id).online = false;
 275            client_cx.update(|cx| {
 276                cx.clear_globals();
 277                drop(client);
 278            });
 279        }
 280
 281        Operation::BounceConnection { user_id } => {
 282            log::info!("Simulating temporary disconnection of user {}", user_id);
 283            let user_connection_ids = server
 284                .connection_pool
 285                .lock()
 286                .user_connection_ids(user_id)
 287                .collect::<Vec<_>>();
 288            if user_connection_ids.is_empty() {
 289                return false;
 290            }
 291            assert_eq!(user_connection_ids.len(), 1);
 292            let peer_id = user_connection_ids[0].into();
 293            server.disconnect_client(peer_id);
 294            deterministic.advance_clock(RECEIVE_TIMEOUT + RECONNECT_TIMEOUT);
 295        }
 296
 297        Operation::RestartServer => {
 298            log::info!("Simulating server restart");
 299            server.reset().await;
 300            deterministic.advance_clock(RECEIVE_TIMEOUT);
 301            server.start().await.unwrap();
 302            deterministic.advance_clock(CLEANUP_TIMEOUT);
 303            let environment = &server.app_state.config.zed_environment;
 304            let stale_room_ids = server
 305                .app_state
 306                .db
 307                .stale_room_ids(environment, server.id())
 308                .await
 309                .unwrap();
 310            assert_eq!(stale_room_ids, vec![]);
 311        }
 312
 313        Operation::MutateClients {
 314            user_ids,
 315            batch_id,
 316            quiesce,
 317        } => {
 318            let mut applied = false;
 319            for user_id in user_ids {
 320                let client_ix = clients
 321                    .iter()
 322                    .position(|(client, cx)| client.current_user_id(cx) == user_id);
 323                let Some(client_ix) = client_ix else { continue };
 324                applied = true;
 325                if let Err(err) = operation_channels[client_ix].unbounded_send(batch_id) {
 326                    log::error!("error signaling user {user_id}: {err}");
 327                }
 328            }
 329
 330            if quiesce && applied {
 331                deterministic.run_until_parked();
 332                check_consistency_between_clients(&clients);
 333            }
 334
 335            return applied;
 336        }
 337    }
 338    true
 339}
 340
 341async fn apply_client_operation(
 342    client: &TestClient,
 343    operation: ClientOperation,
 344    cx: &mut TestAppContext,
 345) -> Result<(), TestError> {
 346    match operation {
 347        ClientOperation::AcceptIncomingCall => {
 348            let active_call = cx.read(ActiveCall::global);
 349            if active_call.read_with(cx, |call, _| call.incoming().borrow().is_none()) {
 350                Err(TestError::Inapplicable)?;
 351            }
 352
 353            log::info!("{}: accepting incoming call", client.username);
 354            active_call
 355                .update(cx, |call, cx| call.accept_incoming(cx))
 356                .await?;
 357        }
 358
 359        ClientOperation::RejectIncomingCall => {
 360            let active_call = cx.read(ActiveCall::global);
 361            if active_call.read_with(cx, |call, _| call.incoming().borrow().is_none()) {
 362                Err(TestError::Inapplicable)?;
 363            }
 364
 365            log::info!("{}: declining incoming call", client.username);
 366            active_call.update(cx, |call, _| call.decline_incoming())?;
 367        }
 368
 369        ClientOperation::LeaveCall => {
 370            let active_call = cx.read(ActiveCall::global);
 371            if active_call.read_with(cx, |call, _| call.room().is_none()) {
 372                Err(TestError::Inapplicable)?;
 373            }
 374
 375            log::info!("{}: hanging up", client.username);
 376            active_call.update(cx, |call, cx| call.hang_up(cx)).await?;
 377        }
 378
 379        ClientOperation::InviteContactToCall { user_id } => {
 380            let active_call = cx.read(ActiveCall::global);
 381
 382            log::info!("{}: inviting {}", client.username, user_id,);
 383            active_call
 384                .update(cx, |call, cx| call.invite(user_id.to_proto(), None, cx))
 385                .await
 386                .log_err();
 387        }
 388
 389        ClientOperation::OpenLocalProject { first_root_name } => {
 390            log::info!(
 391                "{}: opening local project at {:?}",
 392                client.username,
 393                first_root_name
 394            );
 395
 396            let root_path = Path::new("/").join(&first_root_name);
 397            client.fs.create_dir(&root_path).await.unwrap();
 398            client
 399                .fs
 400                .create_file(&root_path.join("main.rs"), Default::default())
 401                .await
 402                .unwrap();
 403            let project = client.build_local_project(root_path, cx).await.0;
 404            ensure_project_shared(&project, client, cx).await;
 405            client.local_projects_mut().push(project.clone());
 406        }
 407
 408        ClientOperation::AddWorktreeToProject {
 409            project_root_name,
 410            new_root_path,
 411        } => {
 412            let project = project_for_root_name(client, &project_root_name, cx)
 413                .ok_or(TestError::Inapplicable)?;
 414
 415            log::info!(
 416                "{}: finding/creating local worktree at {:?} to project with root path {}",
 417                client.username,
 418                new_root_path,
 419                project_root_name
 420            );
 421
 422            ensure_project_shared(&project, client, cx).await;
 423            if !client.fs.paths().contains(&new_root_path) {
 424                client.fs.create_dir(&new_root_path).await.unwrap();
 425            }
 426            project
 427                .update(cx, |project, cx| {
 428                    project.find_or_create_local_worktree(&new_root_path, true, cx)
 429                })
 430                .await
 431                .unwrap();
 432        }
 433
 434        ClientOperation::CloseRemoteProject { project_root_name } => {
 435            let project = project_for_root_name(client, &project_root_name, cx)
 436                .ok_or(TestError::Inapplicable)?;
 437
 438            log::info!(
 439                "{}: closing remote project with root path {}",
 440                client.username,
 441                project_root_name,
 442            );
 443
 444            let ix = client
 445                .remote_projects()
 446                .iter()
 447                .position(|p| p == &project)
 448                .unwrap();
 449            cx.update(|_| {
 450                client.remote_projects_mut().remove(ix);
 451                client.buffers().retain(|p, _| *p != project);
 452                drop(project);
 453            });
 454        }
 455
 456        ClientOperation::OpenRemoteProject {
 457            host_id,
 458            first_root_name,
 459        } => {
 460            let active_call = cx.read(ActiveCall::global);
 461            let project = active_call
 462                .update(cx, |call, cx| {
 463                    let room = call.room().cloned()?;
 464                    let participant = room
 465                        .read(cx)
 466                        .remote_participants()
 467                        .get(&host_id.to_proto())?;
 468                    let project_id = participant
 469                        .projects
 470                        .iter()
 471                        .find(|project| project.worktree_root_names[0] == first_root_name)?
 472                        .id;
 473                    Some(room.update(cx, |room, cx| {
 474                        room.join_project(
 475                            project_id,
 476                            client.language_registry.clone(),
 477                            FakeFs::new(cx.background().clone()),
 478                            cx,
 479                        )
 480                    }))
 481                })
 482                .ok_or(TestError::Inapplicable)?;
 483
 484            log::info!(
 485                "{}: joining remote project of user {}, root name {}",
 486                client.username,
 487                host_id,
 488                first_root_name,
 489            );
 490
 491            let project = project.await?;
 492            client.remote_projects_mut().push(project.clone());
 493        }
 494
 495        ClientOperation::CreateWorktreeEntry {
 496            project_root_name,
 497            is_local,
 498            full_path,
 499            is_dir,
 500        } => {
 501            let project = project_for_root_name(client, &project_root_name, cx)
 502                .ok_or(TestError::Inapplicable)?;
 503            let project_path = project_path_for_full_path(&project, &full_path, cx)
 504                .ok_or(TestError::Inapplicable)?;
 505
 506            log::info!(
 507                "{}: creating {} at path {:?} in {} project {}",
 508                client.username,
 509                if is_dir { "dir" } else { "file" },
 510                full_path,
 511                if is_local { "local" } else { "remote" },
 512                project_root_name,
 513            );
 514
 515            ensure_project_shared(&project, client, cx).await;
 516            project
 517                .update(cx, |p, cx| p.create_entry(project_path, is_dir, cx))
 518                .unwrap()
 519                .await?;
 520        }
 521
 522        ClientOperation::OpenBuffer {
 523            project_root_name,
 524            is_local,
 525            full_path,
 526        } => {
 527            let project = project_for_root_name(client, &project_root_name, cx)
 528                .ok_or(TestError::Inapplicable)?;
 529            let project_path = project_path_for_full_path(&project, &full_path, cx)
 530                .ok_or(TestError::Inapplicable)?;
 531
 532            log::info!(
 533                "{}: opening buffer {:?} in {} project {}",
 534                client.username,
 535                full_path,
 536                if is_local { "local" } else { "remote" },
 537                project_root_name,
 538            );
 539
 540            ensure_project_shared(&project, client, cx).await;
 541            let buffer = project
 542                .update(cx, |project, cx| project.open_buffer(project_path, cx))
 543                .await?;
 544            client.buffers_for_project(&project).insert(buffer);
 545        }
 546
 547        ClientOperation::EditBuffer {
 548            project_root_name,
 549            is_local,
 550            full_path,
 551            edits,
 552        } => {
 553            let project = project_for_root_name(client, &project_root_name, cx)
 554                .ok_or(TestError::Inapplicable)?;
 555            let buffer = buffer_for_full_path(client, &project, &full_path, cx)
 556                .ok_or(TestError::Inapplicable)?;
 557
 558            log::info!(
 559                "{}: editing buffer {:?} in {} project {} with {:?}",
 560                client.username,
 561                full_path,
 562                if is_local { "local" } else { "remote" },
 563                project_root_name,
 564                edits
 565            );
 566
 567            ensure_project_shared(&project, client, cx).await;
 568            buffer.update(cx, |buffer, cx| {
 569                let snapshot = buffer.snapshot();
 570                buffer.edit(
 571                    edits.into_iter().map(|(range, text)| {
 572                        let start = snapshot.clip_offset(range.start, Bias::Left);
 573                        let end = snapshot.clip_offset(range.end, Bias::Right);
 574                        (start..end, text)
 575                    }),
 576                    None,
 577                    cx,
 578                );
 579            });
 580        }
 581
 582        ClientOperation::CloseBuffer {
 583            project_root_name,
 584            is_local,
 585            full_path,
 586        } => {
 587            let project = project_for_root_name(client, &project_root_name, cx)
 588                .ok_or(TestError::Inapplicable)?;
 589            let buffer = buffer_for_full_path(client, &project, &full_path, cx)
 590                .ok_or(TestError::Inapplicable)?;
 591
 592            log::info!(
 593                "{}: closing buffer {:?} in {} project {}",
 594                client.username,
 595                full_path,
 596                if is_local { "local" } else { "remote" },
 597                project_root_name
 598            );
 599
 600            ensure_project_shared(&project, client, cx).await;
 601            cx.update(|_| {
 602                client.buffers_for_project(&project).remove(&buffer);
 603                drop(buffer);
 604            });
 605        }
 606
 607        ClientOperation::SaveBuffer {
 608            project_root_name,
 609            is_local,
 610            full_path,
 611            detach,
 612        } => {
 613            let project = project_for_root_name(client, &project_root_name, cx)
 614                .ok_or(TestError::Inapplicable)?;
 615            let buffer = buffer_for_full_path(client, &project, &full_path, cx)
 616                .ok_or(TestError::Inapplicable)?;
 617
 618            log::info!(
 619                "{}: saving buffer {:?} in {} project {}, {}",
 620                client.username,
 621                full_path,
 622                if is_local { "local" } else { "remote" },
 623                project_root_name,
 624                if detach { "detaching" } else { "awaiting" }
 625            );
 626
 627            ensure_project_shared(&project, client, cx).await;
 628            let requested_version = buffer.read_with(cx, |buffer, _| buffer.version());
 629            let save = project.update(cx, |project, cx| project.save_buffer(buffer, cx));
 630            let save = cx.background().spawn(async move {
 631                let (saved_version, _, _) = save
 632                    .await
 633                    .map_err(|err| anyhow!("save request failed: {:?}", err))?;
 634                assert!(saved_version.observed_all(&requested_version));
 635                anyhow::Ok(())
 636            });
 637            if detach {
 638                cx.update(|cx| save.detach_and_log_err(cx));
 639            } else {
 640                save.await?;
 641            }
 642        }
 643
 644        ClientOperation::RequestLspDataInBuffer {
 645            project_root_name,
 646            is_local,
 647            full_path,
 648            offset,
 649            kind,
 650            detach,
 651        } => {
 652            let project = project_for_root_name(client, &project_root_name, cx)
 653                .ok_or(TestError::Inapplicable)?;
 654            let buffer = buffer_for_full_path(client, &project, &full_path, cx)
 655                .ok_or(TestError::Inapplicable)?;
 656
 657            log::info!(
 658                "{}: request LSP {:?} for buffer {:?} in {} project {}, {}",
 659                client.username,
 660                kind,
 661                full_path,
 662                if is_local { "local" } else { "remote" },
 663                project_root_name,
 664                if detach { "detaching" } else { "awaiting" }
 665            );
 666
 667            use futures::{FutureExt as _, TryFutureExt as _};
 668            let offset = buffer.read_with(cx, |b, _| b.clip_offset(offset, Bias::Left));
 669            let request = cx.foreground().spawn(project.update(cx, |project, cx| {
 670                match kind {
 671                    LspRequestKind::Rename => project
 672                        .prepare_rename(buffer, offset, cx)
 673                        .map_ok(|_| ())
 674                        .boxed(),
 675                    LspRequestKind::Completion => project
 676                        .completions(&buffer, offset, cx)
 677                        .map_ok(|_| ())
 678                        .boxed(),
 679                    LspRequestKind::CodeAction => project
 680                        .code_actions(&buffer, offset..offset, cx)
 681                        .map_ok(|_| ())
 682                        .boxed(),
 683                    LspRequestKind::Definition => project
 684                        .definition(&buffer, offset, cx)
 685                        .map_ok(|_| ())
 686                        .boxed(),
 687                    LspRequestKind::Highlights => project
 688                        .document_highlights(&buffer, offset, cx)
 689                        .map_ok(|_| ())
 690                        .boxed(),
 691                }
 692            }));
 693            if detach {
 694                request.detach();
 695            } else {
 696                request.await?;
 697            }
 698        }
 699
 700        ClientOperation::SearchProject {
 701            project_root_name,
 702            is_local,
 703            query,
 704            detach,
 705        } => {
 706            let project = project_for_root_name(client, &project_root_name, cx)
 707                .ok_or(TestError::Inapplicable)?;
 708
 709            log::info!(
 710                "{}: search {} project {} for {:?}, {}",
 711                client.username,
 712                if is_local { "local" } else { "remote" },
 713                project_root_name,
 714                query,
 715                if detach { "detaching" } else { "awaiting" }
 716            );
 717
 718            let search = project.update(cx, |project, cx| {
 719                project.search(SearchQuery::text(query, false, false), cx)
 720            });
 721            drop(project);
 722            let search = cx.background().spawn(async move {
 723                search
 724                    .await
 725                    .map_err(|err| anyhow!("search request failed: {:?}", err))
 726            });
 727            if detach {
 728                cx.update(|cx| search.detach_and_log_err(cx));
 729            } else {
 730                search.await?;
 731            }
 732        }
 733
 734        ClientOperation::WriteFsEntry {
 735            path,
 736            is_dir,
 737            content,
 738        } => {
 739            if !client
 740                .fs
 741                .directories()
 742                .contains(&path.parent().unwrap().to_owned())
 743            {
 744                return Err(TestError::Inapplicable);
 745            }
 746
 747            if is_dir {
 748                log::info!("{}: creating dir at {:?}", client.username, path);
 749                client.fs.create_dir(&path).await.unwrap();
 750            } else {
 751                let exists = client.fs.metadata(&path).await?.is_some();
 752                let verb = if exists { "updating" } else { "creating" };
 753                log::info!("{}: {} file at {:?}", verb, client.username, path);
 754
 755                client
 756                    .fs
 757                    .save(&path, &content.as_str().into(), fs::LineEnding::Unix)
 758                    .await
 759                    .unwrap();
 760            }
 761        }
 762
 763        ClientOperation::WriteGitIndex {
 764            repo_path,
 765            contents,
 766        } => {
 767            if !client.fs.directories().contains(&repo_path) {
 768                return Err(TestError::Inapplicable);
 769            }
 770
 771            log::info!(
 772                "{}: writing git index for repo {:?}: {:?}",
 773                client.username,
 774                repo_path,
 775                contents
 776            );
 777
 778            let dot_git_dir = repo_path.join(".git");
 779            let contents = contents
 780                .iter()
 781                .map(|(path, contents)| (path.as_path(), contents.clone()))
 782                .collect::<Vec<_>>();
 783            if client.fs.metadata(&dot_git_dir).await?.is_none() {
 784                client.fs.create_dir(&dot_git_dir).await?;
 785            }
 786            client.fs.set_index_for_repo(&dot_git_dir, &contents).await;
 787        }
 788    }
 789    Ok(())
 790}
 791
 792fn check_consistency_between_clients(clients: &[(Rc<TestClient>, TestAppContext)]) {
 793    for (client, client_cx) in clients {
 794        for guest_project in client.remote_projects().iter() {
 795            guest_project.read_with(client_cx, |guest_project, cx| {
 796                let host_project = clients.iter().find_map(|(client, cx)| {
 797                    let project = client
 798                        .local_projects()
 799                        .iter()
 800                        .find(|host_project| {
 801                            host_project.read_with(cx, |host_project, _| {
 802                                host_project.remote_id() == guest_project.remote_id()
 803                            })
 804                        })?
 805                        .clone();
 806                    Some((project, cx))
 807                });
 808
 809                if !guest_project.is_read_only() {
 810                    if let Some((host_project, host_cx)) = host_project {
 811                        let host_worktree_snapshots =
 812                            host_project.read_with(host_cx, |host_project, cx| {
 813                                host_project
 814                                    .worktrees(cx)
 815                                    .map(|worktree| {
 816                                        let worktree = worktree.read(cx);
 817                                        (worktree.id(), worktree.snapshot())
 818                                    })
 819                                    .collect::<BTreeMap<_, _>>()
 820                            });
 821                        let guest_worktree_snapshots = guest_project
 822                            .worktrees(cx)
 823                            .map(|worktree| {
 824                                let worktree = worktree.read(cx);
 825                                (worktree.id(), worktree.snapshot())
 826                            })
 827                            .collect::<BTreeMap<_, _>>();
 828
 829                        assert_eq!(
 830                            guest_worktree_snapshots.values().map(|w| w.abs_path()).collect::<Vec<_>>(),
 831                            host_worktree_snapshots.values().map(|w| w.abs_path()).collect::<Vec<_>>(),
 832                            "{} has different worktrees than the host for project {:?}",
 833                            client.username, guest_project.remote_id(),
 834                        );
 835
 836                        for (id, host_snapshot) in &host_worktree_snapshots {
 837                            let guest_snapshot = &guest_worktree_snapshots[id];
 838                            assert_eq!(
 839                                guest_snapshot.root_name(),
 840                                host_snapshot.root_name(),
 841                                "{} has different root name than the host for worktree {}, project {:?}",
 842                                client.username,
 843                                id,
 844                                guest_project.remote_id(),
 845                            );
 846                            assert_eq!(
 847                                guest_snapshot.abs_path(),
 848                                host_snapshot.abs_path(),
 849                                "{} has different abs path than the host for worktree {}, project: {:?}",
 850                                client.username,
 851                                id,
 852                                guest_project.remote_id(),
 853                            );
 854                            assert_eq!(
 855                                guest_snapshot.entries(false).collect::<Vec<_>>(),
 856                                host_snapshot.entries(false).collect::<Vec<_>>(),
 857                                "{} has different snapshot than the host for worktree {:?} and project {:?}",
 858                                client.username,
 859                                host_snapshot.abs_path(),
 860                                guest_project.remote_id(),
 861                            );
 862                            assert_eq!(guest_snapshot.scan_id(), host_snapshot.scan_id(),
 863                                "{} has different scan id than the host for worktree {:?} and project {:?}",
 864                                client.username,
 865                                host_snapshot.abs_path(),
 866                                guest_project.remote_id(),
 867                            );
 868                        }
 869                    }
 870                }
 871
 872                for buffer in guest_project.opened_buffers(cx) {
 873                    let buffer = buffer.read(cx);
 874                    assert_eq!(
 875                        buffer.deferred_ops_len(),
 876                        0,
 877                        "{} has deferred operations for buffer {:?} in project {:?}",
 878                        client.username,
 879                        buffer.file().unwrap().full_path(cx),
 880                        guest_project.remote_id(),
 881                    );
 882                }
 883            });
 884        }
 885
 886        let buffers = client.buffers().clone();
 887        for (guest_project, guest_buffers) in &buffers {
 888            let project_id = if guest_project.read_with(client_cx, |project, _| {
 889                project.is_local() || project.is_read_only()
 890            }) {
 891                continue;
 892            } else {
 893                guest_project
 894                    .read_with(client_cx, |project, _| project.remote_id())
 895                    .unwrap()
 896            };
 897            let guest_user_id = client.user_id().unwrap();
 898
 899            let host_project = clients.iter().find_map(|(client, cx)| {
 900                let project = client
 901                    .local_projects()
 902                    .iter()
 903                    .find(|host_project| {
 904                        host_project.read_with(cx, |host_project, _| {
 905                            host_project.remote_id() == Some(project_id)
 906                        })
 907                    })?
 908                    .clone();
 909                Some((client.user_id().unwrap(), project, cx))
 910            });
 911
 912            let (host_user_id, host_project, host_cx) =
 913                if let Some((host_user_id, host_project, host_cx)) = host_project {
 914                    (host_user_id, host_project, host_cx)
 915                } else {
 916                    continue;
 917                };
 918
 919            for guest_buffer in guest_buffers {
 920                let buffer_id = guest_buffer.read_with(client_cx, |buffer, _| buffer.remote_id());
 921                let host_buffer = host_project.read_with(host_cx, |project, cx| {
 922                    project.buffer_for_id(buffer_id, cx).unwrap_or_else(|| {
 923                        panic!(
 924                            "host does not have buffer for guest:{}, peer:{:?}, id:{}",
 925                            client.username,
 926                            client.peer_id(),
 927                            buffer_id
 928                        )
 929                    })
 930                });
 931                let path = host_buffer
 932                    .read_with(host_cx, |buffer, cx| buffer.file().unwrap().full_path(cx));
 933
 934                assert_eq!(
 935                    guest_buffer.read_with(client_cx, |buffer, _| buffer.deferred_ops_len()),
 936                    0,
 937                    "{}, buffer {}, path {:?} has deferred operations",
 938                    client.username,
 939                    buffer_id,
 940                    path,
 941                );
 942                assert_eq!(
 943                    guest_buffer.read_with(client_cx, |buffer, _| buffer.text()),
 944                    host_buffer.read_with(host_cx, |buffer, _| buffer.text()),
 945                    "{}, buffer {}, path {:?}, differs from the host's buffer",
 946                    client.username,
 947                    buffer_id,
 948                    path
 949                );
 950
 951                let host_file = host_buffer.read_with(host_cx, |b, _| b.file().cloned());
 952                let guest_file = guest_buffer.read_with(client_cx, |b, _| b.file().cloned());
 953                match (host_file, guest_file) {
 954                    (Some(host_file), Some(guest_file)) => {
 955                        assert_eq!(guest_file.path(), host_file.path());
 956                        assert_eq!(guest_file.is_deleted(), host_file.is_deleted());
 957                        assert_eq!(
 958                            guest_file.mtime(),
 959                            host_file.mtime(),
 960                            "guest {} mtime does not match host {} for path {:?} in project {}",
 961                            guest_user_id,
 962                            host_user_id,
 963                            guest_file.path(),
 964                            project_id,
 965                        );
 966                    }
 967                    (None, None) => {}
 968                    (None, _) => panic!("host's file is None, guest's isn't"),
 969                    (_, None) => panic!("guest's file is None, hosts's isn't"),
 970                }
 971
 972                let host_diff_base =
 973                    host_buffer.read_with(host_cx, |b, _| b.diff_base().map(ToString::to_string));
 974                let guest_diff_base = guest_buffer
 975                    .read_with(client_cx, |b, _| b.diff_base().map(ToString::to_string));
 976                assert_eq!(
 977                    guest_diff_base, host_diff_base,
 978                    "guest {} diff base does not match host's for path {path:?} in project {project_id}",
 979                    client.username
 980                );
 981
 982                let host_saved_version =
 983                    host_buffer.read_with(host_cx, |b, _| b.saved_version().clone());
 984                let guest_saved_version =
 985                    guest_buffer.read_with(client_cx, |b, _| b.saved_version().clone());
 986                assert_eq!(
 987                    guest_saved_version, host_saved_version,
 988                    "guest {} saved version does not match host's for path {path:?} in project {project_id}",
 989                    client.username
 990                );
 991
 992                let host_saved_version_fingerprint =
 993                    host_buffer.read_with(host_cx, |b, _| b.saved_version_fingerprint());
 994                let guest_saved_version_fingerprint =
 995                    guest_buffer.read_with(client_cx, |b, _| b.saved_version_fingerprint());
 996                assert_eq!(
 997                    guest_saved_version_fingerprint, host_saved_version_fingerprint,
 998                    "guest {} saved fingerprint does not match host's for path {path:?} in project {project_id}",
 999                    client.username
1000                );
1001
1002                let host_saved_mtime = host_buffer.read_with(host_cx, |b, _| b.saved_mtime());
1003                let guest_saved_mtime = guest_buffer.read_with(client_cx, |b, _| b.saved_mtime());
1004                assert_eq!(
1005                    guest_saved_mtime, host_saved_mtime,
1006                    "guest {} saved mtime does not match host's for path {path:?} in project {project_id}",
1007                    client.username
1008                );
1009
1010                let host_is_dirty = host_buffer.read_with(host_cx, |b, _| b.is_dirty());
1011                let guest_is_dirty = guest_buffer.read_with(client_cx, |b, _| b.is_dirty());
1012                assert_eq!(guest_is_dirty, host_is_dirty,
1013                    "guest {} dirty status does not match host's for path {path:?} in project {project_id}",
1014                    client.username
1015                );
1016
1017                let host_has_conflict = host_buffer.read_with(host_cx, |b, _| b.has_conflict());
1018                let guest_has_conflict = guest_buffer.read_with(client_cx, |b, _| b.has_conflict());
1019                assert_eq!(guest_has_conflict, host_has_conflict,
1020                    "guest {} conflict status does not match host's for path {path:?} in project {project_id}",
1021                    client.username
1022                );
1023            }
1024        }
1025    }
1026}
1027
1028struct TestPlan {
1029    rng: StdRng,
1030    replay: bool,
1031    stored_operations: Vec<(StoredOperation, Arc<AtomicBool>)>,
1032    max_operations: usize,
1033    operation_ix: usize,
1034    users: Vec<UserTestPlan>,
1035    next_batch_id: usize,
1036    allow_server_restarts: bool,
1037    allow_client_reconnection: bool,
1038    allow_client_disconnection: bool,
1039}
1040
1041struct UserTestPlan {
1042    user_id: UserId,
1043    username: String,
1044    next_root_id: usize,
1045    operation_ix: usize,
1046    online: bool,
1047}
1048
1049#[derive(Clone, Debug, Serialize, Deserialize)]
1050#[serde(untagged)]
1051enum StoredOperation {
1052    Server(Operation),
1053    Client {
1054        user_id: UserId,
1055        batch_id: usize,
1056        operation: ClientOperation,
1057    },
1058}
1059
1060#[derive(Clone, Debug, Serialize, Deserialize)]
1061enum Operation {
1062    AddConnection {
1063        user_id: UserId,
1064    },
1065    RemoveConnection {
1066        user_id: UserId,
1067    },
1068    BounceConnection {
1069        user_id: UserId,
1070    },
1071    RestartServer,
1072    MutateClients {
1073        batch_id: usize,
1074        #[serde(skip_serializing)]
1075        #[serde(skip_deserializing)]
1076        user_ids: Vec<UserId>,
1077        quiesce: bool,
1078    },
1079}
1080
1081#[derive(Clone, Debug, Serialize, Deserialize)]
1082enum ClientOperation {
1083    AcceptIncomingCall,
1084    RejectIncomingCall,
1085    LeaveCall,
1086    InviteContactToCall {
1087        user_id: UserId,
1088    },
1089    OpenLocalProject {
1090        first_root_name: String,
1091    },
1092    OpenRemoteProject {
1093        host_id: UserId,
1094        first_root_name: String,
1095    },
1096    AddWorktreeToProject {
1097        project_root_name: String,
1098        new_root_path: PathBuf,
1099    },
1100    CloseRemoteProject {
1101        project_root_name: String,
1102    },
1103    OpenBuffer {
1104        project_root_name: String,
1105        is_local: bool,
1106        full_path: PathBuf,
1107    },
1108    SearchProject {
1109        project_root_name: String,
1110        is_local: bool,
1111        query: String,
1112        detach: bool,
1113    },
1114    EditBuffer {
1115        project_root_name: String,
1116        is_local: bool,
1117        full_path: PathBuf,
1118        edits: Vec<(Range<usize>, Arc<str>)>,
1119    },
1120    CloseBuffer {
1121        project_root_name: String,
1122        is_local: bool,
1123        full_path: PathBuf,
1124    },
1125    SaveBuffer {
1126        project_root_name: String,
1127        is_local: bool,
1128        full_path: PathBuf,
1129        detach: bool,
1130    },
1131    RequestLspDataInBuffer {
1132        project_root_name: String,
1133        is_local: bool,
1134        full_path: PathBuf,
1135        offset: usize,
1136        kind: LspRequestKind,
1137        detach: bool,
1138    },
1139    CreateWorktreeEntry {
1140        project_root_name: String,
1141        is_local: bool,
1142        full_path: PathBuf,
1143        is_dir: bool,
1144    },
1145    WriteFsEntry {
1146        path: PathBuf,
1147        is_dir: bool,
1148        content: String,
1149    },
1150    WriteGitIndex {
1151        repo_path: PathBuf,
1152        contents: Vec<(PathBuf, String)>,
1153    },
1154}
1155
1156#[derive(Clone, Debug, Serialize, Deserialize)]
1157enum LspRequestKind {
1158    Rename,
1159    Completion,
1160    CodeAction,
1161    Definition,
1162    Highlights,
1163}
1164
1165enum TestError {
1166    Inapplicable,
1167    Other(anyhow::Error),
1168}
1169
1170impl From<anyhow::Error> for TestError {
1171    fn from(value: anyhow::Error) -> Self {
1172        Self::Other(value)
1173    }
1174}
1175
1176impl TestPlan {
1177    fn new(mut rng: StdRng, users: Vec<UserTestPlan>, max_operations: usize) -> Self {
1178        Self {
1179            replay: false,
1180            allow_server_restarts: rng.gen_bool(0.7),
1181            allow_client_reconnection: rng.gen_bool(0.7),
1182            allow_client_disconnection: rng.gen_bool(0.1),
1183            stored_operations: Vec::new(),
1184            operation_ix: 0,
1185            next_batch_id: 0,
1186            max_operations,
1187            users,
1188            rng,
1189        }
1190    }
1191
1192    fn deserialize(&mut self, json: Vec<u8>) {
1193        let stored_operations: Vec<StoredOperation> = serde_json::from_slice(&json).unwrap();
1194        self.replay = true;
1195        self.stored_operations = stored_operations
1196            .iter()
1197            .cloned()
1198            .enumerate()
1199            .map(|(i, mut operation)| {
1200                if let StoredOperation::Server(Operation::MutateClients {
1201                    batch_id: current_batch_id,
1202                    user_ids,
1203                    ..
1204                }) = &mut operation
1205                {
1206                    assert!(user_ids.is_empty());
1207                    user_ids.extend(stored_operations[i + 1..].iter().filter_map(|operation| {
1208                        if let StoredOperation::Client {
1209                            user_id, batch_id, ..
1210                        } = operation
1211                        {
1212                            if batch_id == current_batch_id {
1213                                return Some(user_id);
1214                            }
1215                        }
1216                        None
1217                    }));
1218                    user_ids.sort_unstable();
1219                }
1220                (operation, Arc::new(AtomicBool::new(false)))
1221            })
1222            .collect()
1223    }
1224
1225    fn serialize(&mut self) -> Vec<u8> {
1226        // Format each operation as one line
1227        let mut json = Vec::new();
1228        json.push(b'[');
1229        for (operation, applied) in &self.stored_operations {
1230            if !applied.load(SeqCst) {
1231                continue;
1232            }
1233            if json.len() > 1 {
1234                json.push(b',');
1235            }
1236            json.extend_from_slice(b"\n  ");
1237            serde_json::to_writer(&mut json, operation).unwrap();
1238        }
1239        json.extend_from_slice(b"\n]\n");
1240        json
1241    }
1242
1243    fn next_server_operation(
1244        &mut self,
1245        clients: &[(Rc<TestClient>, TestAppContext)],
1246    ) -> Option<(Operation, Arc<AtomicBool>)> {
1247        if self.replay {
1248            while let Some(stored_operation) = self.stored_operations.get(self.operation_ix) {
1249                self.operation_ix += 1;
1250                if let (StoredOperation::Server(operation), applied) = stored_operation {
1251                    return Some((operation.clone(), applied.clone()));
1252                }
1253            }
1254            None
1255        } else {
1256            let operation = self.generate_server_operation(clients)?;
1257            let applied = Arc::new(AtomicBool::new(false));
1258            self.stored_operations
1259                .push((StoredOperation::Server(operation.clone()), applied.clone()));
1260            Some((operation, applied))
1261        }
1262    }
1263
1264    fn next_client_operation(
1265        &mut self,
1266        client: &TestClient,
1267        current_batch_id: usize,
1268        cx: &TestAppContext,
1269    ) -> Option<(ClientOperation, Arc<AtomicBool>)> {
1270        let current_user_id = client.current_user_id(cx);
1271        let user_ix = self
1272            .users
1273            .iter()
1274            .position(|user| user.user_id == current_user_id)
1275            .unwrap();
1276        let user_plan = &mut self.users[user_ix];
1277
1278        if self.replay {
1279            while let Some(stored_operation) = self.stored_operations.get(user_plan.operation_ix) {
1280                user_plan.operation_ix += 1;
1281                if let (
1282                    StoredOperation::Client {
1283                        user_id, operation, ..
1284                    },
1285                    applied,
1286                ) = stored_operation
1287                {
1288                    if user_id == &current_user_id {
1289                        return Some((operation.clone(), applied.clone()));
1290                    }
1291                }
1292            }
1293            None
1294        } else {
1295            let operation = self.generate_client_operation(current_user_id, client, cx)?;
1296            let applied = Arc::new(AtomicBool::new(false));
1297            self.stored_operations.push((
1298                StoredOperation::Client {
1299                    user_id: current_user_id,
1300                    batch_id: current_batch_id,
1301                    operation: operation.clone(),
1302                },
1303                applied.clone(),
1304            ));
1305            Some((operation, applied))
1306        }
1307    }
1308
1309    fn generate_server_operation(
1310        &mut self,
1311        clients: &[(Rc<TestClient>, TestAppContext)],
1312    ) -> Option<Operation> {
1313        if self.operation_ix == self.max_operations {
1314            return None;
1315        }
1316
1317        Some(loop {
1318            break match self.rng.gen_range(0..100) {
1319                0..=29 if clients.len() < self.users.len() => {
1320                    let user = self
1321                        .users
1322                        .iter()
1323                        .filter(|u| !u.online)
1324                        .choose(&mut self.rng)
1325                        .unwrap();
1326                    self.operation_ix += 1;
1327                    Operation::AddConnection {
1328                        user_id: user.user_id,
1329                    }
1330                }
1331                30..=34 if clients.len() > 1 && self.allow_client_disconnection => {
1332                    let (client, cx) = &clients[self.rng.gen_range(0..clients.len())];
1333                    let user_id = client.current_user_id(cx);
1334                    self.operation_ix += 1;
1335                    Operation::RemoveConnection { user_id }
1336                }
1337                35..=39 if clients.len() > 1 && self.allow_client_reconnection => {
1338                    let (client, cx) = &clients[self.rng.gen_range(0..clients.len())];
1339                    let user_id = client.current_user_id(cx);
1340                    self.operation_ix += 1;
1341                    Operation::BounceConnection { user_id }
1342                }
1343                40..=44 if self.allow_server_restarts && clients.len() > 1 => {
1344                    self.operation_ix += 1;
1345                    Operation::RestartServer
1346                }
1347                _ if !clients.is_empty() => {
1348                    let count = self
1349                        .rng
1350                        .gen_range(1..10)
1351                        .min(self.max_operations - self.operation_ix);
1352                    let batch_id = util::post_inc(&mut self.next_batch_id);
1353                    let mut user_ids = (0..count)
1354                        .map(|_| {
1355                            let ix = self.rng.gen_range(0..clients.len());
1356                            let (client, cx) = &clients[ix];
1357                            client.current_user_id(cx)
1358                        })
1359                        .collect::<Vec<_>>();
1360                    user_ids.sort_unstable();
1361                    Operation::MutateClients {
1362                        user_ids,
1363                        batch_id,
1364                        quiesce: self.rng.gen_bool(0.7),
1365                    }
1366                }
1367                _ => continue,
1368            };
1369        })
1370    }
1371
1372    fn generate_client_operation(
1373        &mut self,
1374        user_id: UserId,
1375        client: &TestClient,
1376        cx: &TestAppContext,
1377    ) -> Option<ClientOperation> {
1378        if self.operation_ix == self.max_operations {
1379            return None;
1380        }
1381
1382        self.operation_ix += 1;
1383        let call = cx.read(ActiveCall::global);
1384        Some(loop {
1385            match self.rng.gen_range(0..100_u32) {
1386                // Mutate the call
1387                0..=29 => {
1388                    // Respond to an incoming call
1389                    if call.read_with(cx, |call, _| call.incoming().borrow().is_some()) {
1390                        break if self.rng.gen_bool(0.7) {
1391                            ClientOperation::AcceptIncomingCall
1392                        } else {
1393                            ClientOperation::RejectIncomingCall
1394                        };
1395                    }
1396
1397                    match self.rng.gen_range(0..100_u32) {
1398                        // Invite a contact to the current call
1399                        0..=70 => {
1400                            let available_contacts =
1401                                client.user_store.read_with(cx, |user_store, _| {
1402                                    user_store
1403                                        .contacts()
1404                                        .iter()
1405                                        .filter(|contact| contact.online && !contact.busy)
1406                                        .cloned()
1407                                        .collect::<Vec<_>>()
1408                                });
1409                            if !available_contacts.is_empty() {
1410                                let contact = available_contacts.choose(&mut self.rng).unwrap();
1411                                break ClientOperation::InviteContactToCall {
1412                                    user_id: UserId(contact.user.id as i32),
1413                                };
1414                            }
1415                        }
1416
1417                        // Leave the current call
1418                        71.. => {
1419                            if self.allow_client_disconnection
1420                                && call.read_with(cx, |call, _| call.room().is_some())
1421                            {
1422                                break ClientOperation::LeaveCall;
1423                            }
1424                        }
1425                    }
1426                }
1427
1428                // Mutate projects
1429                30..=59 => match self.rng.gen_range(0..100_u32) {
1430                    // Open a new project
1431                    0..=70 => {
1432                        // Open a remote project
1433                        if let Some(room) = call.read_with(cx, |call, _| call.room().cloned()) {
1434                            let existing_remote_project_ids = cx.read(|cx| {
1435                                client
1436                                    .remote_projects()
1437                                    .iter()
1438                                    .map(|p| p.read(cx).remote_id().unwrap())
1439                                    .collect::<Vec<_>>()
1440                            });
1441                            let new_remote_projects = room.read_with(cx, |room, _| {
1442                                room.remote_participants()
1443                                    .values()
1444                                    .flat_map(|participant| {
1445                                        participant.projects.iter().filter_map(|project| {
1446                                            if existing_remote_project_ids.contains(&project.id) {
1447                                                None
1448                                            } else {
1449                                                Some((
1450                                                    UserId::from_proto(participant.user.id),
1451                                                    project.worktree_root_names[0].clone(),
1452                                                ))
1453                                            }
1454                                        })
1455                                    })
1456                                    .collect::<Vec<_>>()
1457                            });
1458                            if !new_remote_projects.is_empty() {
1459                                let (host_id, first_root_name) =
1460                                    new_remote_projects.choose(&mut self.rng).unwrap().clone();
1461                                break ClientOperation::OpenRemoteProject {
1462                                    host_id,
1463                                    first_root_name,
1464                                };
1465                            }
1466                        }
1467                        // Open a local project
1468                        else {
1469                            let first_root_name = self.next_root_dir_name(user_id);
1470                            break ClientOperation::OpenLocalProject { first_root_name };
1471                        }
1472                    }
1473
1474                    // Close a remote project
1475                    71..=80 => {
1476                        if !client.remote_projects().is_empty() {
1477                            let project = client
1478                                .remote_projects()
1479                                .choose(&mut self.rng)
1480                                .unwrap()
1481                                .clone();
1482                            let first_root_name = root_name_for_project(&project, cx);
1483                            break ClientOperation::CloseRemoteProject {
1484                                project_root_name: first_root_name,
1485                            };
1486                        }
1487                    }
1488
1489                    // Mutate project worktrees
1490                    81.. => match self.rng.gen_range(0..100_u32) {
1491                        // Add a worktree to a local project
1492                        0..=50 => {
1493                            let Some(project) = client
1494                                .local_projects()
1495                                .choose(&mut self.rng)
1496                                .cloned() else { continue };
1497                            let project_root_name = root_name_for_project(&project, cx);
1498                            let mut paths = client.fs.paths();
1499                            paths.remove(0);
1500                            let new_root_path = if paths.is_empty() || self.rng.gen() {
1501                                Path::new("/").join(&self.next_root_dir_name(user_id))
1502                            } else {
1503                                paths.choose(&mut self.rng).unwrap().clone()
1504                            };
1505                            break ClientOperation::AddWorktreeToProject {
1506                                project_root_name,
1507                                new_root_path,
1508                            };
1509                        }
1510
1511                        // Add an entry to a worktree
1512                        _ => {
1513                            let Some(project) = choose_random_project(client, &mut self.rng) else { continue };
1514                            let project_root_name = root_name_for_project(&project, cx);
1515                            let is_local = project.read_with(cx, |project, _| project.is_local());
1516                            let worktree = project.read_with(cx, |project, cx| {
1517                                project
1518                                    .worktrees(cx)
1519                                    .filter(|worktree| {
1520                                        let worktree = worktree.read(cx);
1521                                        worktree.is_visible()
1522                                            && worktree.entries(false).any(|e| e.is_file())
1523                                            && worktree.root_entry().map_or(false, |e| e.is_dir())
1524                                    })
1525                                    .choose(&mut self.rng)
1526                            });
1527                            let Some(worktree) = worktree else { continue };
1528                            let is_dir = self.rng.gen::<bool>();
1529                            let mut full_path =
1530                                worktree.read_with(cx, |w, _| PathBuf::from(w.root_name()));
1531                            full_path.push(gen_file_name(&mut self.rng));
1532                            if !is_dir {
1533                                full_path.set_extension("rs");
1534                            }
1535                            break ClientOperation::CreateWorktreeEntry {
1536                                project_root_name,
1537                                is_local,
1538                                full_path,
1539                                is_dir,
1540                            };
1541                        }
1542                    },
1543                },
1544
1545                // Query and mutate buffers
1546                60..=90 => {
1547                    let Some(project) = choose_random_project(client, &mut self.rng) else { continue };
1548                    let project_root_name = root_name_for_project(&project, cx);
1549                    let is_local = project.read_with(cx, |project, _| project.is_local());
1550
1551                    match self.rng.gen_range(0..100_u32) {
1552                        // Manipulate an existing buffer
1553                        0..=70 => {
1554                            let Some(buffer) = client
1555                                .buffers_for_project(&project)
1556                                .iter()
1557                                .choose(&mut self.rng)
1558                                .cloned() else { continue };
1559
1560                            let full_path = buffer
1561                                .read_with(cx, |buffer, cx| buffer.file().unwrap().full_path(cx));
1562
1563                            match self.rng.gen_range(0..100_u32) {
1564                                // Close the buffer
1565                                0..=15 => {
1566                                    break ClientOperation::CloseBuffer {
1567                                        project_root_name,
1568                                        is_local,
1569                                        full_path,
1570                                    };
1571                                }
1572                                // Save the buffer
1573                                16..=29 if buffer.read_with(cx, |b, _| b.is_dirty()) => {
1574                                    let detach = self.rng.gen_bool(0.3);
1575                                    break ClientOperation::SaveBuffer {
1576                                        project_root_name,
1577                                        is_local,
1578                                        full_path,
1579                                        detach,
1580                                    };
1581                                }
1582                                // Edit the buffer
1583                                30..=69 => {
1584                                    let edits = buffer.read_with(cx, |buffer, _| {
1585                                        buffer.get_random_edits(&mut self.rng, 3)
1586                                    });
1587                                    break ClientOperation::EditBuffer {
1588                                        project_root_name,
1589                                        is_local,
1590                                        full_path,
1591                                        edits,
1592                                    };
1593                                }
1594                                // Make an LSP request
1595                                _ => {
1596                                    let offset = buffer.read_with(cx, |buffer, _| {
1597                                        buffer.clip_offset(
1598                                            self.rng.gen_range(0..=buffer.len()),
1599                                            language::Bias::Left,
1600                                        )
1601                                    });
1602                                    let detach = self.rng.gen();
1603                                    break ClientOperation::RequestLspDataInBuffer {
1604                                        project_root_name,
1605                                        full_path,
1606                                        offset,
1607                                        is_local,
1608                                        kind: match self.rng.gen_range(0..5_u32) {
1609                                            0 => LspRequestKind::Rename,
1610                                            1 => LspRequestKind::Highlights,
1611                                            2 => LspRequestKind::Definition,
1612                                            3 => LspRequestKind::CodeAction,
1613                                            4.. => LspRequestKind::Completion,
1614                                        },
1615                                        detach,
1616                                    };
1617                                }
1618                            }
1619                        }
1620
1621                        71..=80 => {
1622                            let query = self.rng.gen_range('a'..='z').to_string();
1623                            let detach = self.rng.gen_bool(0.3);
1624                            break ClientOperation::SearchProject {
1625                                project_root_name,
1626                                is_local,
1627                                query,
1628                                detach,
1629                            };
1630                        }
1631
1632                        // Open a buffer
1633                        81.. => {
1634                            let worktree = project.read_with(cx, |project, cx| {
1635                                project
1636                                    .worktrees(cx)
1637                                    .filter(|worktree| {
1638                                        let worktree = worktree.read(cx);
1639                                        worktree.is_visible()
1640                                            && worktree.entries(false).any(|e| e.is_file())
1641                                    })
1642                                    .choose(&mut self.rng)
1643                            });
1644                            let Some(worktree) = worktree else { continue };
1645                            let full_path = worktree.read_with(cx, |worktree, _| {
1646                                let entry = worktree
1647                                    .entries(false)
1648                                    .filter(|e| e.is_file())
1649                                    .choose(&mut self.rng)
1650                                    .unwrap();
1651                                if entry.path.as_ref() == Path::new("") {
1652                                    Path::new(worktree.root_name()).into()
1653                                } else {
1654                                    Path::new(worktree.root_name()).join(&entry.path)
1655                                }
1656                            });
1657                            break ClientOperation::OpenBuffer {
1658                                project_root_name,
1659                                is_local,
1660                                full_path,
1661                            };
1662                        }
1663                    }
1664                }
1665
1666                // Update a git index
1667                91..=95 => {
1668                    let repo_path = client
1669                        .fs
1670                        .directories()
1671                        .choose(&mut self.rng)
1672                        .unwrap()
1673                        .clone();
1674
1675                    let mut file_paths = client
1676                        .fs
1677                        .files()
1678                        .into_iter()
1679                        .filter(|path| path.starts_with(&repo_path))
1680                        .collect::<Vec<_>>();
1681                    let count = self.rng.gen_range(0..=file_paths.len());
1682                    file_paths.shuffle(&mut self.rng);
1683                    file_paths.truncate(count);
1684
1685                    let mut contents = Vec::new();
1686                    for abs_child_file_path in &file_paths {
1687                        let child_file_path = abs_child_file_path
1688                            .strip_prefix(&repo_path)
1689                            .unwrap()
1690                            .to_path_buf();
1691                        let new_base = Alphanumeric.sample_string(&mut self.rng, 16);
1692                        contents.push((child_file_path, new_base));
1693                    }
1694
1695                    break ClientOperation::WriteGitIndex {
1696                        repo_path,
1697                        contents,
1698                    };
1699                }
1700
1701                // Create or update a file or directory
1702                96.. => {
1703                    let is_dir = self.rng.gen::<bool>();
1704                    let content;
1705                    let mut path;
1706                    let dir_paths = client.fs.directories();
1707
1708                    if is_dir {
1709                        content = String::new();
1710                        path = dir_paths.choose(&mut self.rng).unwrap().clone();
1711                        path.push(gen_file_name(&mut self.rng));
1712                    } else {
1713                        content = Alphanumeric.sample_string(&mut self.rng, 16);
1714
1715                        // Create a new file or overwrite an existing file
1716                        let file_paths = client.fs.files();
1717                        if file_paths.is_empty() || self.rng.gen_bool(0.5) {
1718                            path = dir_paths.choose(&mut self.rng).unwrap().clone();
1719                            path.push(gen_file_name(&mut self.rng));
1720                            path.set_extension("rs");
1721                        } else {
1722                            path = file_paths.choose(&mut self.rng).unwrap().clone()
1723                        };
1724                    }
1725                    break ClientOperation::WriteFsEntry {
1726                        path,
1727                        is_dir,
1728                        content,
1729                    };
1730                }
1731            }
1732        })
1733    }
1734
1735    fn next_root_dir_name(&mut self, user_id: UserId) -> String {
1736        let user_ix = self
1737            .users
1738            .iter()
1739            .position(|user| user.user_id == user_id)
1740            .unwrap();
1741        let root_id = util::post_inc(&mut self.users[user_ix].next_root_id);
1742        format!("dir-{user_id}-{root_id}")
1743    }
1744
1745    fn user(&mut self, user_id: UserId) -> &mut UserTestPlan {
1746        let ix = self
1747            .users
1748            .iter()
1749            .position(|user| user.user_id == user_id)
1750            .unwrap();
1751        &mut self.users[ix]
1752    }
1753}
1754
1755async fn simulate_client(
1756    client: Rc<TestClient>,
1757    mut operation_rx: futures::channel::mpsc::UnboundedReceiver<usize>,
1758    plan: Arc<Mutex<TestPlan>>,
1759    mut cx: TestAppContext,
1760) {
1761    // Setup language server
1762    let mut language = Language::new(
1763        LanguageConfig {
1764            name: "Rust".into(),
1765            path_suffixes: vec!["rs".to_string()],
1766            ..Default::default()
1767        },
1768        None,
1769    );
1770    let _fake_language_servers = language
1771        .set_fake_lsp_adapter(Arc::new(FakeLspAdapter {
1772            name: "the-fake-language-server",
1773            capabilities: lsp::LanguageServer::full_capabilities(),
1774            initializer: Some(Box::new({
1775                let fs = client.fs.clone();
1776                move |fake_server: &mut FakeLanguageServer| {
1777                    fake_server.handle_request::<lsp::request::Completion, _, _>(
1778                        |_, _| async move {
1779                            Ok(Some(lsp::CompletionResponse::Array(vec![
1780                                lsp::CompletionItem {
1781                                    text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
1782                                        range: lsp::Range::new(
1783                                            lsp::Position::new(0, 0),
1784                                            lsp::Position::new(0, 0),
1785                                        ),
1786                                        new_text: "the-new-text".to_string(),
1787                                    })),
1788                                    ..Default::default()
1789                                },
1790                            ])))
1791                        },
1792                    );
1793
1794                    fake_server.handle_request::<lsp::request::CodeActionRequest, _, _>(
1795                        |_, _| async move {
1796                            Ok(Some(vec![lsp::CodeActionOrCommand::CodeAction(
1797                                lsp::CodeAction {
1798                                    title: "the-code-action".to_string(),
1799                                    ..Default::default()
1800                                },
1801                            )]))
1802                        },
1803                    );
1804
1805                    fake_server.handle_request::<lsp::request::PrepareRenameRequest, _, _>(
1806                        |params, _| async move {
1807                            Ok(Some(lsp::PrepareRenameResponse::Range(lsp::Range::new(
1808                                params.position,
1809                                params.position,
1810                            ))))
1811                        },
1812                    );
1813
1814                    fake_server.handle_request::<lsp::request::GotoDefinition, _, _>({
1815                        let fs = fs.clone();
1816                        move |_, cx| {
1817                            let background = cx.background();
1818                            let mut rng = background.rng();
1819                            let count = rng.gen_range::<usize, _>(1..3);
1820                            let files = fs.files();
1821                            let files = (0..count)
1822                                .map(|_| files.choose(&mut *rng).unwrap().clone())
1823                                .collect::<Vec<_>>();
1824                            async move {
1825                                log::info!("LSP: Returning definitions in files {:?}", &files);
1826                                Ok(Some(lsp::GotoDefinitionResponse::Array(
1827                                    files
1828                                        .into_iter()
1829                                        .map(|file| lsp::Location {
1830                                            uri: lsp::Url::from_file_path(file).unwrap(),
1831                                            range: Default::default(),
1832                                        })
1833                                        .collect(),
1834                                )))
1835                            }
1836                        }
1837                    });
1838
1839                    fake_server.handle_request::<lsp::request::DocumentHighlightRequest, _, _>(
1840                        move |_, cx| {
1841                            let mut highlights = Vec::new();
1842                            let background = cx.background();
1843                            let mut rng = background.rng();
1844
1845                            let highlight_count = rng.gen_range(1..=5);
1846                            for _ in 0..highlight_count {
1847                                let start_row = rng.gen_range(0..100);
1848                                let start_column = rng.gen_range(0..100);
1849                                let end_row = rng.gen_range(0..100);
1850                                let end_column = rng.gen_range(0..100);
1851                                let start = PointUtf16::new(start_row, start_column);
1852                                let end = PointUtf16::new(end_row, end_column);
1853                                let range = if start > end { end..start } else { start..end };
1854                                highlights.push(lsp::DocumentHighlight {
1855                                    range: range_to_lsp(range.clone()),
1856                                    kind: Some(lsp::DocumentHighlightKind::READ),
1857                                });
1858                            }
1859                            highlights.sort_unstable_by_key(|highlight| {
1860                                (highlight.range.start, highlight.range.end)
1861                            });
1862                            async move { Ok(Some(highlights)) }
1863                        },
1864                    );
1865                }
1866            })),
1867            ..Default::default()
1868        }))
1869        .await;
1870    client.language_registry.add(Arc::new(language));
1871
1872    while let Some(batch_id) = operation_rx.next().await {
1873        let Some((operation, applied)) = plan.lock().next_client_operation(&client, batch_id, &cx) else { break };
1874        applied.store(true, SeqCst);
1875        match apply_client_operation(&client, operation, &mut cx).await {
1876            Ok(()) => {}
1877            Err(TestError::Inapplicable) => {
1878                applied.store(false, SeqCst);
1879                log::info!("skipped operation");
1880            }
1881            Err(TestError::Other(error)) => {
1882                log::error!("{} error: {}", client.username, error);
1883            }
1884        }
1885        cx.background().simulate_random_delay().await;
1886    }
1887    log::info!("{}: done", client.username);
1888}
1889
1890fn buffer_for_full_path(
1891    client: &TestClient,
1892    project: &ModelHandle<Project>,
1893    full_path: &PathBuf,
1894    cx: &TestAppContext,
1895) -> Option<ModelHandle<language::Buffer>> {
1896    client
1897        .buffers_for_project(project)
1898        .iter()
1899        .find(|buffer| {
1900            buffer.read_with(cx, |buffer, cx| {
1901                buffer.file().unwrap().full_path(cx) == *full_path
1902            })
1903        })
1904        .cloned()
1905}
1906
1907fn project_for_root_name(
1908    client: &TestClient,
1909    root_name: &str,
1910    cx: &TestAppContext,
1911) -> Option<ModelHandle<Project>> {
1912    if let Some(ix) = project_ix_for_root_name(&*client.local_projects(), root_name, cx) {
1913        return Some(client.local_projects()[ix].clone());
1914    }
1915    if let Some(ix) = project_ix_for_root_name(&*client.remote_projects(), root_name, cx) {
1916        return Some(client.remote_projects()[ix].clone());
1917    }
1918    None
1919}
1920
1921fn project_ix_for_root_name(
1922    projects: &[ModelHandle<Project>],
1923    root_name: &str,
1924    cx: &TestAppContext,
1925) -> Option<usize> {
1926    projects.iter().position(|project| {
1927        project.read_with(cx, |project, cx| {
1928            let worktree = project.visible_worktrees(cx).next().unwrap();
1929            worktree.read(cx).root_name() == root_name
1930        })
1931    })
1932}
1933
1934fn root_name_for_project(project: &ModelHandle<Project>, cx: &TestAppContext) -> String {
1935    project.read_with(cx, |project, cx| {
1936        project
1937            .visible_worktrees(cx)
1938            .next()
1939            .unwrap()
1940            .read(cx)
1941            .root_name()
1942            .to_string()
1943    })
1944}
1945
1946fn project_path_for_full_path(
1947    project: &ModelHandle<Project>,
1948    full_path: &Path,
1949    cx: &TestAppContext,
1950) -> Option<ProjectPath> {
1951    let mut components = full_path.components();
1952    let root_name = components.next().unwrap().as_os_str().to_str().unwrap();
1953    let path = components.as_path().into();
1954    let worktree_id = project.read_with(cx, |project, cx| {
1955        project.worktrees(cx).find_map(|worktree| {
1956            let worktree = worktree.read(cx);
1957            if worktree.root_name() == root_name {
1958                Some(worktree.id())
1959            } else {
1960                None
1961            }
1962        })
1963    })?;
1964    Some(ProjectPath { worktree_id, path })
1965}
1966
1967async fn ensure_project_shared(
1968    project: &ModelHandle<Project>,
1969    client: &TestClient,
1970    cx: &mut TestAppContext,
1971) {
1972    let first_root_name = root_name_for_project(project, cx);
1973    let active_call = cx.read(ActiveCall::global);
1974    if active_call.read_with(cx, |call, _| call.room().is_some())
1975        && project.read_with(cx, |project, _| project.is_local() && !project.is_shared())
1976    {
1977        match active_call
1978            .update(cx, |call, cx| call.share_project(project.clone(), cx))
1979            .await
1980        {
1981            Ok(project_id) => {
1982                log::info!(
1983                    "{}: shared project {} with id {}",
1984                    client.username,
1985                    first_root_name,
1986                    project_id
1987                );
1988            }
1989            Err(error) => {
1990                log::error!(
1991                    "{}: error sharing project {}: {:?}",
1992                    client.username,
1993                    first_root_name,
1994                    error
1995                );
1996            }
1997        }
1998    }
1999}
2000
2001fn choose_random_project(client: &TestClient, rng: &mut StdRng) -> Option<ModelHandle<Project>> {
2002    client
2003        .local_projects()
2004        .iter()
2005        .chain(client.remote_projects().iter())
2006        .choose(rng)
2007        .cloned()
2008}
2009
2010fn gen_file_name(rng: &mut StdRng) -> String {
2011    let mut name = String::new();
2012    for _ in 0..10 {
2013        let letter = rng.gen_range('a'..='z');
2014        name.push(letter);
2015    }
2016    name
2017}
2018
2019fn path_env_var(name: &str) -> Option<PathBuf> {
2020    let value = env::var(name).ok()?;
2021    let mut path = PathBuf::from(value);
2022    if path.is_relative() {
2023        let mut abs_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
2024        abs_path.pop();
2025        abs_path.pop();
2026        abs_path.push(path);
2027        path = abs_path
2028    }
2029    Some(path)
2030}