mirror of
https://github.com/zed-industries/zed.git
synced 2024-09-19 10:29:35 +03:00
Extract randomized test infrastructure for use in other tests
This commit is contained in:
parent
ec5ff20b4c
commit
66c3879306
1
Cargo.lock
generated
1
Cargo.lock
generated
@ -1456,6 +1456,7 @@ name = "collab"
|
|||||||
version = "0.19.0"
|
version = "0.19.0"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"anyhow",
|
"anyhow",
|
||||||
|
"async-trait",
|
||||||
"async-tungstenite",
|
"async-tungstenite",
|
||||||
"audio",
|
"audio",
|
||||||
"axum",
|
"axum",
|
||||||
|
@ -80,6 +80,7 @@ theme = { path = "../theme" }
|
|||||||
workspace = { path = "../workspace", features = ["test-support"] }
|
workspace = { path = "../workspace", features = ["test-support"] }
|
||||||
collab_ui = { path = "../collab_ui", features = ["test-support"] }
|
collab_ui = { path = "../collab_ui", features = ["test-support"] }
|
||||||
|
|
||||||
|
async-trait.workspace = true
|
||||||
ctor.workspace = true
|
ctor.workspace = true
|
||||||
env_logger.workspace = true
|
env_logger.workspace = true
|
||||||
indoc.workspace = true
|
indoc.workspace = true
|
||||||
|
@ -1,555 +1,18 @@
|
|||||||
use crate::{
|
use call::Room;
|
||||||
db::{tests::TestDb, NewUserParams, UserId},
|
use gpui::{ModelHandle, TestAppContext};
|
||||||
executor::Executor,
|
|
||||||
rpc::{Server, CLEANUP_TIMEOUT},
|
|
||||||
AppState,
|
|
||||||
};
|
|
||||||
use anyhow::anyhow;
|
|
||||||
use call::{ActiveCall, Room};
|
|
||||||
use channel::ChannelStore;
|
|
||||||
use client::{
|
|
||||||
self, proto::PeerId, Client, Connection, Credentials, EstablishConnectionError, UserStore,
|
|
||||||
};
|
|
||||||
use collections::{HashMap, HashSet};
|
|
||||||
use fs::FakeFs;
|
|
||||||
use futures::{channel::oneshot, StreamExt as _};
|
|
||||||
use gpui::{executor::Deterministic, ModelHandle, Task, TestAppContext, WindowHandle};
|
|
||||||
use language::LanguageRegistry;
|
|
||||||
use parking_lot::Mutex;
|
|
||||||
use project::{Project, WorktreeId};
|
|
||||||
use settings::SettingsStore;
|
|
||||||
use std::{
|
|
||||||
cell::{Ref, RefCell, RefMut},
|
|
||||||
env,
|
|
||||||
ops::{Deref, DerefMut},
|
|
||||||
path::Path,
|
|
||||||
sync::{
|
|
||||||
atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst},
|
|
||||||
Arc,
|
|
||||||
},
|
|
||||||
};
|
|
||||||
use util::http::FakeHttpClient;
|
|
||||||
use workspace::Workspace;
|
|
||||||
|
|
||||||
mod channel_buffer_tests;
|
mod channel_buffer_tests;
|
||||||
mod channel_tests;
|
mod channel_tests;
|
||||||
mod integration_tests;
|
mod integration_tests;
|
||||||
mod randomized_integration_tests;
|
mod random_channel_buffer_tests;
|
||||||
|
mod random_project_collaboration_tests;
|
||||||
|
mod randomized_test_helpers;
|
||||||
|
mod test_server;
|
||||||
|
|
||||||
struct TestServer {
|
pub use randomized_test_helpers::{
|
||||||
app_state: Arc<AppState>,
|
run_randomized_test, save_randomized_test_plan, RandomizedTest, TestError, UserTestPlan,
|
||||||
server: Arc<Server>,
|
};
|
||||||
connection_killers: Arc<Mutex<HashMap<PeerId, Arc<AtomicBool>>>>,
|
pub use test_server::{TestClient, TestServer};
|
||||||
forbid_connections: Arc<AtomicBool>,
|
|
||||||
_test_db: TestDb,
|
|
||||||
test_live_kit_server: Arc<live_kit_client::TestServer>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl TestServer {
|
|
||||||
async fn start(deterministic: &Arc<Deterministic>) -> Self {
|
|
||||||
static NEXT_LIVE_KIT_SERVER_ID: AtomicUsize = AtomicUsize::new(0);
|
|
||||||
|
|
||||||
let use_postgres = env::var("USE_POSTGRES").ok();
|
|
||||||
let use_postgres = use_postgres.as_deref();
|
|
||||||
let test_db = if use_postgres == Some("true") || use_postgres == Some("1") {
|
|
||||||
TestDb::postgres(deterministic.build_background())
|
|
||||||
} else {
|
|
||||||
TestDb::sqlite(deterministic.build_background())
|
|
||||||
};
|
|
||||||
let live_kit_server_id = NEXT_LIVE_KIT_SERVER_ID.fetch_add(1, SeqCst);
|
|
||||||
let live_kit_server = live_kit_client::TestServer::create(
|
|
||||||
format!("http://livekit.{}.test", live_kit_server_id),
|
|
||||||
format!("devkey-{}", live_kit_server_id),
|
|
||||||
format!("secret-{}", live_kit_server_id),
|
|
||||||
deterministic.build_background(),
|
|
||||||
)
|
|
||||||
.unwrap();
|
|
||||||
let app_state = Self::build_app_state(&test_db, &live_kit_server).await;
|
|
||||||
let epoch = app_state
|
|
||||||
.db
|
|
||||||
.create_server(&app_state.config.zed_environment)
|
|
||||||
.await
|
|
||||||
.unwrap();
|
|
||||||
let server = Server::new(
|
|
||||||
epoch,
|
|
||||||
app_state.clone(),
|
|
||||||
Executor::Deterministic(deterministic.build_background()),
|
|
||||||
);
|
|
||||||
server.start().await.unwrap();
|
|
||||||
// Advance clock to ensure the server's cleanup task is finished.
|
|
||||||
deterministic.advance_clock(CLEANUP_TIMEOUT);
|
|
||||||
Self {
|
|
||||||
app_state,
|
|
||||||
server,
|
|
||||||
connection_killers: Default::default(),
|
|
||||||
forbid_connections: Default::default(),
|
|
||||||
_test_db: test_db,
|
|
||||||
test_live_kit_server: live_kit_server,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
async fn reset(&self) {
|
|
||||||
self.app_state.db.reset();
|
|
||||||
let epoch = self
|
|
||||||
.app_state
|
|
||||||
.db
|
|
||||||
.create_server(&self.app_state.config.zed_environment)
|
|
||||||
.await
|
|
||||||
.unwrap();
|
|
||||||
self.server.reset(epoch);
|
|
||||||
}
|
|
||||||
|
|
||||||
async fn create_client(&mut self, cx: &mut TestAppContext, name: &str) -> TestClient {
|
|
||||||
cx.update(|cx| {
|
|
||||||
if cx.has_global::<SettingsStore>() {
|
|
||||||
panic!("Same cx used to create two test clients")
|
|
||||||
}
|
|
||||||
cx.set_global(SettingsStore::test(cx));
|
|
||||||
});
|
|
||||||
|
|
||||||
let http = FakeHttpClient::with_404_response();
|
|
||||||
let user_id = if let Ok(Some(user)) = self.app_state.db.get_user_by_github_login(name).await
|
|
||||||
{
|
|
||||||
user.id
|
|
||||||
} else {
|
|
||||||
self.app_state
|
|
||||||
.db
|
|
||||||
.create_user(
|
|
||||||
&format!("{name}@example.com"),
|
|
||||||
false,
|
|
||||||
NewUserParams {
|
|
||||||
github_login: name.into(),
|
|
||||||
github_user_id: 0,
|
|
||||||
invite_count: 0,
|
|
||||||
},
|
|
||||||
)
|
|
||||||
.await
|
|
||||||
.expect("creating user failed")
|
|
||||||
.user_id
|
|
||||||
};
|
|
||||||
let client_name = name.to_string();
|
|
||||||
let mut client = cx.read(|cx| Client::new(http.clone(), cx));
|
|
||||||
let server = self.server.clone();
|
|
||||||
let db = self.app_state.db.clone();
|
|
||||||
let connection_killers = self.connection_killers.clone();
|
|
||||||
let forbid_connections = self.forbid_connections.clone();
|
|
||||||
|
|
||||||
Arc::get_mut(&mut client)
|
|
||||||
.unwrap()
|
|
||||||
.set_id(user_id.0 as usize)
|
|
||||||
.override_authenticate(move |cx| {
|
|
||||||
cx.spawn(|_| async move {
|
|
||||||
let access_token = "the-token".to_string();
|
|
||||||
Ok(Credentials {
|
|
||||||
user_id: user_id.0 as u64,
|
|
||||||
access_token,
|
|
||||||
})
|
|
||||||
})
|
|
||||||
})
|
|
||||||
.override_establish_connection(move |credentials, cx| {
|
|
||||||
assert_eq!(credentials.user_id, user_id.0 as u64);
|
|
||||||
assert_eq!(credentials.access_token, "the-token");
|
|
||||||
|
|
||||||
let server = server.clone();
|
|
||||||
let db = db.clone();
|
|
||||||
let connection_killers = connection_killers.clone();
|
|
||||||
let forbid_connections = forbid_connections.clone();
|
|
||||||
let client_name = client_name.clone();
|
|
||||||
cx.spawn(move |cx| async move {
|
|
||||||
if forbid_connections.load(SeqCst) {
|
|
||||||
Err(EstablishConnectionError::other(anyhow!(
|
|
||||||
"server is forbidding connections"
|
|
||||||
)))
|
|
||||||
} else {
|
|
||||||
let (client_conn, server_conn, killed) =
|
|
||||||
Connection::in_memory(cx.background());
|
|
||||||
let (connection_id_tx, connection_id_rx) = oneshot::channel();
|
|
||||||
let user = db
|
|
||||||
.get_user_by_id(user_id)
|
|
||||||
.await
|
|
||||||
.expect("retrieving user failed")
|
|
||||||
.unwrap();
|
|
||||||
cx.background()
|
|
||||||
.spawn(server.handle_connection(
|
|
||||||
server_conn,
|
|
||||||
client_name,
|
|
||||||
user,
|
|
||||||
Some(connection_id_tx),
|
|
||||||
Executor::Deterministic(cx.background()),
|
|
||||||
))
|
|
||||||
.detach();
|
|
||||||
let connection_id = connection_id_rx.await.unwrap();
|
|
||||||
connection_killers
|
|
||||||
.lock()
|
|
||||||
.insert(connection_id.into(), killed);
|
|
||||||
Ok(client_conn)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
});
|
|
||||||
|
|
||||||
let fs = FakeFs::new(cx.background());
|
|
||||||
let user_store = cx.add_model(|cx| UserStore::new(client.clone(), http, cx));
|
|
||||||
let channel_store =
|
|
||||||
cx.add_model(|cx| ChannelStore::new(client.clone(), user_store.clone(), cx));
|
|
||||||
let app_state = Arc::new(workspace::AppState {
|
|
||||||
client: client.clone(),
|
|
||||||
user_store: user_store.clone(),
|
|
||||||
channel_store: channel_store.clone(),
|
|
||||||
languages: Arc::new(LanguageRegistry::test()),
|
|
||||||
fs: fs.clone(),
|
|
||||||
build_window_options: |_, _, _| Default::default(),
|
|
||||||
initialize_workspace: |_, _, _, _| Task::ready(Ok(())),
|
|
||||||
background_actions: || &[],
|
|
||||||
});
|
|
||||||
|
|
||||||
cx.update(|cx| {
|
|
||||||
theme::init((), cx);
|
|
||||||
Project::init(&client, cx);
|
|
||||||
client::init(&client, cx);
|
|
||||||
language::init(cx);
|
|
||||||
editor::init_settings(cx);
|
|
||||||
workspace::init(app_state.clone(), cx);
|
|
||||||
audio::init((), cx);
|
|
||||||
call::init(client.clone(), user_store.clone(), cx);
|
|
||||||
channel::init(&client);
|
|
||||||
});
|
|
||||||
|
|
||||||
client
|
|
||||||
.authenticate_and_connect(false, &cx.to_async())
|
|
||||||
.await
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
let client = TestClient {
|
|
||||||
app_state,
|
|
||||||
username: name.to_string(),
|
|
||||||
state: Default::default(),
|
|
||||||
};
|
|
||||||
client.wait_for_current_user(cx).await;
|
|
||||||
client
|
|
||||||
}
|
|
||||||
|
|
||||||
fn disconnect_client(&self, peer_id: PeerId) {
|
|
||||||
self.connection_killers
|
|
||||||
.lock()
|
|
||||||
.remove(&peer_id)
|
|
||||||
.unwrap()
|
|
||||||
.store(true, SeqCst);
|
|
||||||
}
|
|
||||||
|
|
||||||
fn forbid_connections(&self) {
|
|
||||||
self.forbid_connections.store(true, SeqCst);
|
|
||||||
}
|
|
||||||
|
|
||||||
fn allow_connections(&self) {
|
|
||||||
self.forbid_connections.store(false, SeqCst);
|
|
||||||
}
|
|
||||||
|
|
||||||
async fn make_contacts(&self, clients: &mut [(&TestClient, &mut TestAppContext)]) {
|
|
||||||
for ix in 1..clients.len() {
|
|
||||||
let (left, right) = clients.split_at_mut(ix);
|
|
||||||
let (client_a, cx_a) = left.last_mut().unwrap();
|
|
||||||
for (client_b, cx_b) in right {
|
|
||||||
client_a
|
|
||||||
.app_state
|
|
||||||
.user_store
|
|
||||||
.update(*cx_a, |store, cx| {
|
|
||||||
store.request_contact(client_b.user_id().unwrap(), cx)
|
|
||||||
})
|
|
||||||
.await
|
|
||||||
.unwrap();
|
|
||||||
cx_a.foreground().run_until_parked();
|
|
||||||
client_b
|
|
||||||
.app_state
|
|
||||||
.user_store
|
|
||||||
.update(*cx_b, |store, cx| {
|
|
||||||
store.respond_to_contact_request(client_a.user_id().unwrap(), true, cx)
|
|
||||||
})
|
|
||||||
.await
|
|
||||||
.unwrap();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
async fn make_channel(
|
|
||||||
&self,
|
|
||||||
channel: &str,
|
|
||||||
admin: (&TestClient, &mut TestAppContext),
|
|
||||||
members: &mut [(&TestClient, &mut TestAppContext)],
|
|
||||||
) -> u64 {
|
|
||||||
let (admin_client, admin_cx) = admin;
|
|
||||||
let channel_id = admin_client
|
|
||||||
.app_state
|
|
||||||
.channel_store
|
|
||||||
.update(admin_cx, |channel_store, cx| {
|
|
||||||
channel_store.create_channel(channel, None, cx)
|
|
||||||
})
|
|
||||||
.await
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
for (member_client, member_cx) in members {
|
|
||||||
admin_client
|
|
||||||
.app_state
|
|
||||||
.channel_store
|
|
||||||
.update(admin_cx, |channel_store, cx| {
|
|
||||||
channel_store.invite_member(
|
|
||||||
channel_id,
|
|
||||||
member_client.user_id().unwrap(),
|
|
||||||
false,
|
|
||||||
cx,
|
|
||||||
)
|
|
||||||
})
|
|
||||||
.await
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
admin_cx.foreground().run_until_parked();
|
|
||||||
|
|
||||||
member_client
|
|
||||||
.app_state
|
|
||||||
.channel_store
|
|
||||||
.update(*member_cx, |channels, _| {
|
|
||||||
channels.respond_to_channel_invite(channel_id, true)
|
|
||||||
})
|
|
||||||
.await
|
|
||||||
.unwrap();
|
|
||||||
}
|
|
||||||
|
|
||||||
channel_id
|
|
||||||
}
|
|
||||||
|
|
||||||
async fn create_room(&self, clients: &mut [(&TestClient, &mut TestAppContext)]) {
|
|
||||||
self.make_contacts(clients).await;
|
|
||||||
|
|
||||||
let (left, right) = clients.split_at_mut(1);
|
|
||||||
let (_client_a, cx_a) = &mut left[0];
|
|
||||||
let active_call_a = cx_a.read(ActiveCall::global);
|
|
||||||
|
|
||||||
for (client_b, cx_b) in right {
|
|
||||||
let user_id_b = client_b.current_user_id(*cx_b).to_proto();
|
|
||||||
active_call_a
|
|
||||||
.update(*cx_a, |call, cx| call.invite(user_id_b, None, cx))
|
|
||||||
.await
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
cx_b.foreground().run_until_parked();
|
|
||||||
let active_call_b = cx_b.read(ActiveCall::global);
|
|
||||||
active_call_b
|
|
||||||
.update(*cx_b, |call, cx| call.accept_incoming(cx))
|
|
||||||
.await
|
|
||||||
.unwrap();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
async fn build_app_state(
|
|
||||||
test_db: &TestDb,
|
|
||||||
fake_server: &live_kit_client::TestServer,
|
|
||||||
) -> Arc<AppState> {
|
|
||||||
Arc::new(AppState {
|
|
||||||
db: test_db.db().clone(),
|
|
||||||
live_kit_client: Some(Arc::new(fake_server.create_api_client())),
|
|
||||||
config: Default::default(),
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Deref for TestServer {
|
|
||||||
type Target = Server;
|
|
||||||
|
|
||||||
fn deref(&self) -> &Self::Target {
|
|
||||||
&self.server
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Drop for TestServer {
|
|
||||||
fn drop(&mut self) {
|
|
||||||
self.server.teardown();
|
|
||||||
self.test_live_kit_server.teardown().unwrap();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
struct TestClient {
|
|
||||||
username: String,
|
|
||||||
state: RefCell<TestClientState>,
|
|
||||||
app_state: Arc<workspace::AppState>,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Default)]
|
|
||||||
struct TestClientState {
|
|
||||||
local_projects: Vec<ModelHandle<Project>>,
|
|
||||||
remote_projects: Vec<ModelHandle<Project>>,
|
|
||||||
buffers: HashMap<ModelHandle<Project>, HashSet<ModelHandle<language::Buffer>>>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Deref for TestClient {
|
|
||||||
type Target = Arc<Client>;
|
|
||||||
|
|
||||||
fn deref(&self) -> &Self::Target {
|
|
||||||
&self.app_state.client
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
struct ContactsSummary {
|
|
||||||
pub current: Vec<String>,
|
|
||||||
pub outgoing_requests: Vec<String>,
|
|
||||||
pub incoming_requests: Vec<String>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl TestClient {
|
|
||||||
pub fn fs(&self) -> &FakeFs {
|
|
||||||
self.app_state.fs.as_fake()
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn channel_store(&self) -> &ModelHandle<ChannelStore> {
|
|
||||||
&self.app_state.channel_store
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn user_store(&self) -> &ModelHandle<UserStore> {
|
|
||||||
&self.app_state.user_store
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn language_registry(&self) -> &Arc<LanguageRegistry> {
|
|
||||||
&self.app_state.languages
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn client(&self) -> &Arc<Client> {
|
|
||||||
&self.app_state.client
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn current_user_id(&self, cx: &TestAppContext) -> UserId {
|
|
||||||
UserId::from_proto(
|
|
||||||
self.app_state
|
|
||||||
.user_store
|
|
||||||
.read_with(cx, |user_store, _| user_store.current_user().unwrap().id),
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
async fn wait_for_current_user(&self, cx: &TestAppContext) {
|
|
||||||
let mut authed_user = self
|
|
||||||
.app_state
|
|
||||||
.user_store
|
|
||||||
.read_with(cx, |user_store, _| user_store.watch_current_user());
|
|
||||||
while authed_user.next().await.unwrap().is_none() {}
|
|
||||||
}
|
|
||||||
|
|
||||||
async fn clear_contacts(&self, cx: &mut TestAppContext) {
|
|
||||||
self.app_state
|
|
||||||
.user_store
|
|
||||||
.update(cx, |store, _| store.clear_contacts())
|
|
||||||
.await;
|
|
||||||
}
|
|
||||||
|
|
||||||
fn local_projects<'a>(&'a self) -> impl Deref<Target = Vec<ModelHandle<Project>>> + 'a {
|
|
||||||
Ref::map(self.state.borrow(), |state| &state.local_projects)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn remote_projects<'a>(&'a self) -> impl Deref<Target = Vec<ModelHandle<Project>>> + 'a {
|
|
||||||
Ref::map(self.state.borrow(), |state| &state.remote_projects)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn local_projects_mut<'a>(&'a self) -> impl DerefMut<Target = Vec<ModelHandle<Project>>> + 'a {
|
|
||||||
RefMut::map(self.state.borrow_mut(), |state| &mut state.local_projects)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn remote_projects_mut<'a>(&'a self) -> impl DerefMut<Target = Vec<ModelHandle<Project>>> + 'a {
|
|
||||||
RefMut::map(self.state.borrow_mut(), |state| &mut state.remote_projects)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn buffers_for_project<'a>(
|
|
||||||
&'a self,
|
|
||||||
project: &ModelHandle<Project>,
|
|
||||||
) -> impl DerefMut<Target = HashSet<ModelHandle<language::Buffer>>> + 'a {
|
|
||||||
RefMut::map(self.state.borrow_mut(), |state| {
|
|
||||||
state.buffers.entry(project.clone()).or_default()
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
fn buffers<'a>(
|
|
||||||
&'a self,
|
|
||||||
) -> impl DerefMut<Target = HashMap<ModelHandle<Project>, HashSet<ModelHandle<language::Buffer>>>> + 'a
|
|
||||||
{
|
|
||||||
RefMut::map(self.state.borrow_mut(), |state| &mut state.buffers)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn summarize_contacts(&self, cx: &TestAppContext) -> ContactsSummary {
|
|
||||||
self.app_state
|
|
||||||
.user_store
|
|
||||||
.read_with(cx, |store, _| ContactsSummary {
|
|
||||||
current: store
|
|
||||||
.contacts()
|
|
||||||
.iter()
|
|
||||||
.map(|contact| contact.user.github_login.clone())
|
|
||||||
.collect(),
|
|
||||||
outgoing_requests: store
|
|
||||||
.outgoing_contact_requests()
|
|
||||||
.iter()
|
|
||||||
.map(|user| user.github_login.clone())
|
|
||||||
.collect(),
|
|
||||||
incoming_requests: store
|
|
||||||
.incoming_contact_requests()
|
|
||||||
.iter()
|
|
||||||
.map(|user| user.github_login.clone())
|
|
||||||
.collect(),
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
async fn build_local_project(
|
|
||||||
&self,
|
|
||||||
root_path: impl AsRef<Path>,
|
|
||||||
cx: &mut TestAppContext,
|
|
||||||
) -> (ModelHandle<Project>, WorktreeId) {
|
|
||||||
let project = cx.update(|cx| {
|
|
||||||
Project::local(
|
|
||||||
self.client().clone(),
|
|
||||||
self.app_state.user_store.clone(),
|
|
||||||
self.app_state.languages.clone(),
|
|
||||||
self.app_state.fs.clone(),
|
|
||||||
cx,
|
|
||||||
)
|
|
||||||
});
|
|
||||||
let (worktree, _) = project
|
|
||||||
.update(cx, |p, cx| {
|
|
||||||
p.find_or_create_local_worktree(root_path, true, cx)
|
|
||||||
})
|
|
||||||
.await
|
|
||||||
.unwrap();
|
|
||||||
worktree
|
|
||||||
.read_with(cx, |tree, _| tree.as_local().unwrap().scan_complete())
|
|
||||||
.await;
|
|
||||||
(project, worktree.read_with(cx, |tree, _| tree.id()))
|
|
||||||
}
|
|
||||||
|
|
||||||
async fn build_remote_project(
|
|
||||||
&self,
|
|
||||||
host_project_id: u64,
|
|
||||||
guest_cx: &mut TestAppContext,
|
|
||||||
) -> ModelHandle<Project> {
|
|
||||||
let active_call = guest_cx.read(ActiveCall::global);
|
|
||||||
let room = active_call.read_with(guest_cx, |call, _| call.room().unwrap().clone());
|
|
||||||
room.update(guest_cx, |room, cx| {
|
|
||||||
room.join_project(
|
|
||||||
host_project_id,
|
|
||||||
self.app_state.languages.clone(),
|
|
||||||
self.app_state.fs.clone(),
|
|
||||||
cx,
|
|
||||||
)
|
|
||||||
})
|
|
||||||
.await
|
|
||||||
.unwrap()
|
|
||||||
}
|
|
||||||
|
|
||||||
fn build_workspace(
|
|
||||||
&self,
|
|
||||||
project: &ModelHandle<Project>,
|
|
||||||
cx: &mut TestAppContext,
|
|
||||||
) -> WindowHandle<Workspace> {
|
|
||||||
cx.add_window(|cx| Workspace::new(0, project.clone(), self.app_state.clone(), cx))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Drop for TestClient {
|
|
||||||
fn drop(&mut self) {
|
|
||||||
self.app_state.client.teardown();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Debug, Eq, PartialEq)]
|
#[derive(Debug, Eq, PartialEq)]
|
||||||
struct RoomParticipants {
|
struct RoomParticipants {
|
||||||
|
49
crates/collab/src/tests/random_channel_buffer_tests.rs
Normal file
49
crates/collab/src/tests/random_channel_buffer_tests.rs
Normal file
@ -0,0 +1,49 @@
|
|||||||
|
use crate::tests::{run_randomized_test, RandomizedTest, TestClient, TestError, UserTestPlan};
|
||||||
|
use anyhow::Result;
|
||||||
|
use async_trait::async_trait;
|
||||||
|
use gpui::{executor::Deterministic, TestAppContext};
|
||||||
|
use rand::rngs::StdRng;
|
||||||
|
use serde_derive::{Deserialize, Serialize};
|
||||||
|
use std::{rc::Rc, sync::Arc};
|
||||||
|
|
||||||
|
#[gpui::test]
|
||||||
|
async fn test_random_channel_buffers(
|
||||||
|
cx: &mut TestAppContext,
|
||||||
|
deterministic: Arc<Deterministic>,
|
||||||
|
rng: StdRng,
|
||||||
|
) {
|
||||||
|
run_randomized_test::<RandomChannelBufferTest>(cx, deterministic, rng).await;
|
||||||
|
}
|
||||||
|
|
||||||
|
struct RandomChannelBufferTest;
|
||||||
|
|
||||||
|
#[derive(Clone, Serialize, Deserialize)]
|
||||||
|
enum ChannelBufferOperation {
|
||||||
|
Join,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[async_trait(?Send)]
|
||||||
|
impl RandomizedTest for RandomChannelBufferTest {
|
||||||
|
type Operation = ChannelBufferOperation;
|
||||||
|
|
||||||
|
fn generate_operation(
|
||||||
|
client: &TestClient,
|
||||||
|
rng: &mut StdRng,
|
||||||
|
plan: &mut UserTestPlan,
|
||||||
|
cx: &TestAppContext,
|
||||||
|
) -> ChannelBufferOperation {
|
||||||
|
ChannelBufferOperation::Join
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn apply_operation(
|
||||||
|
client: &TestClient,
|
||||||
|
operation: ChannelBufferOperation,
|
||||||
|
cx: &mut TestAppContext,
|
||||||
|
) -> Result<(), TestError> {
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn on_client_added(client: &Rc<TestClient>) {}
|
||||||
|
|
||||||
|
fn on_clients_quiesced(clients: &[(Rc<TestClient>, TestAppContext)]) {}
|
||||||
|
}
|
1573
crates/collab/src/tests/random_project_collaboration_tests.rs
Normal file
1573
crates/collab/src/tests/random_project_collaboration_tests.rs
Normal file
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
694
crates/collab/src/tests/randomized_test_helpers.rs
Normal file
694
crates/collab/src/tests/randomized_test_helpers.rs
Normal file
@ -0,0 +1,694 @@
|
|||||||
|
use crate::{
|
||||||
|
db::{self, Database, NewUserParams, UserId},
|
||||||
|
rpc::{CLEANUP_TIMEOUT, RECONNECT_TIMEOUT},
|
||||||
|
tests::{TestClient, TestServer},
|
||||||
|
};
|
||||||
|
use async_trait::async_trait;
|
||||||
|
use futures::StreamExt;
|
||||||
|
use gpui::{executor::Deterministic, Task, TestAppContext};
|
||||||
|
use parking_lot::Mutex;
|
||||||
|
use rand::prelude::*;
|
||||||
|
use rpc::RECEIVE_TIMEOUT;
|
||||||
|
use serde::{de::DeserializeOwned, Deserialize, Serialize};
|
||||||
|
use settings::SettingsStore;
|
||||||
|
use std::{
|
||||||
|
env,
|
||||||
|
path::PathBuf,
|
||||||
|
rc::Rc,
|
||||||
|
sync::{
|
||||||
|
atomic::{AtomicBool, Ordering::SeqCst},
|
||||||
|
Arc,
|
||||||
|
},
|
||||||
|
};
|
||||||
|
|
||||||
|
lazy_static::lazy_static! {
|
||||||
|
static ref PLAN_LOAD_PATH: Option<PathBuf> = path_env_var("LOAD_PLAN");
|
||||||
|
static ref PLAN_SAVE_PATH: Option<PathBuf> = path_env_var("SAVE_PLAN");
|
||||||
|
static ref MAX_PEERS: usize = env::var("MAX_PEERS")
|
||||||
|
.map(|i| i.parse().expect("invalid `MAX_PEERS` variable"))
|
||||||
|
.unwrap_or(3);
|
||||||
|
static ref MAX_OPERATIONS: usize = env::var("OPERATIONS")
|
||||||
|
.map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
|
||||||
|
.unwrap_or(10);
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
static LOADED_PLAN_JSON: Mutex<Option<Vec<u8>>> = Mutex::new(None);
|
||||||
|
static LAST_PLAN: Mutex<Option<Box<dyn Send + FnOnce() -> Vec<u8>>>> = Mutex::new(None);
|
||||||
|
|
||||||
|
struct TestPlan<T: RandomizedTest> {
|
||||||
|
rng: StdRng,
|
||||||
|
replay: bool,
|
||||||
|
stored_operations: Vec<(StoredOperation<T::Operation>, Arc<AtomicBool>)>,
|
||||||
|
max_operations: usize,
|
||||||
|
operation_ix: usize,
|
||||||
|
users: Vec<UserTestPlan>,
|
||||||
|
next_batch_id: usize,
|
||||||
|
allow_server_restarts: bool,
|
||||||
|
allow_client_reconnection: bool,
|
||||||
|
allow_client_disconnection: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
pub struct UserTestPlan {
|
||||||
|
pub user_id: UserId,
|
||||||
|
pub username: String,
|
||||||
|
pub allow_client_reconnection: bool,
|
||||||
|
pub allow_client_disconnection: bool,
|
||||||
|
next_root_id: usize,
|
||||||
|
operation_ix: usize,
|
||||||
|
online: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||||
|
#[serde(untagged)]
|
||||||
|
enum StoredOperation<T> {
|
||||||
|
Server(ServerOperation),
|
||||||
|
Client {
|
||||||
|
user_id: UserId,
|
||||||
|
batch_id: usize,
|
||||||
|
operation: T,
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||||
|
enum ServerOperation {
|
||||||
|
AddConnection {
|
||||||
|
user_id: UserId,
|
||||||
|
},
|
||||||
|
RemoveConnection {
|
||||||
|
user_id: UserId,
|
||||||
|
},
|
||||||
|
BounceConnection {
|
||||||
|
user_id: UserId,
|
||||||
|
},
|
||||||
|
RestartServer,
|
||||||
|
MutateClients {
|
||||||
|
batch_id: usize,
|
||||||
|
#[serde(skip_serializing)]
|
||||||
|
#[serde(skip_deserializing)]
|
||||||
|
user_ids: Vec<UserId>,
|
||||||
|
quiesce: bool,
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
pub enum TestError {
|
||||||
|
Inapplicable,
|
||||||
|
Other(anyhow::Error),
|
||||||
|
}
|
||||||
|
|
||||||
|
#[async_trait(?Send)]
|
||||||
|
pub trait RandomizedTest: 'static + Sized {
|
||||||
|
type Operation: Send + Clone + Serialize + DeserializeOwned;
|
||||||
|
|
||||||
|
fn generate_operation(
|
||||||
|
client: &TestClient,
|
||||||
|
rng: &mut StdRng,
|
||||||
|
plan: &mut UserTestPlan,
|
||||||
|
cx: &TestAppContext,
|
||||||
|
) -> Self::Operation;
|
||||||
|
|
||||||
|
async fn on_client_added(client: &Rc<TestClient>);
|
||||||
|
|
||||||
|
fn on_clients_quiesced(client: &[(Rc<TestClient>, TestAppContext)]);
|
||||||
|
|
||||||
|
async fn apply_operation(
|
||||||
|
client: &TestClient,
|
||||||
|
operation: Self::Operation,
|
||||||
|
cx: &mut TestAppContext,
|
||||||
|
) -> Result<(), TestError>;
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn run_randomized_test<T: RandomizedTest>(
|
||||||
|
cx: &mut TestAppContext,
|
||||||
|
deterministic: Arc<Deterministic>,
|
||||||
|
rng: StdRng,
|
||||||
|
) {
|
||||||
|
deterministic.forbid_parking();
|
||||||
|
let mut server = TestServer::start(&deterministic).await;
|
||||||
|
let plan = TestPlan::<T>::new(server.app_state.db.clone(), rng).await;
|
||||||
|
|
||||||
|
LAST_PLAN.lock().replace({
|
||||||
|
let plan = plan.clone();
|
||||||
|
Box::new(move || plan.lock().serialize())
|
||||||
|
});
|
||||||
|
|
||||||
|
let mut clients = Vec::new();
|
||||||
|
let mut client_tasks = Vec::new();
|
||||||
|
let mut operation_channels = Vec::new();
|
||||||
|
loop {
|
||||||
|
let Some((next_operation, applied)) = plan.lock().next_server_operation(&clients) else {
|
||||||
|
break;
|
||||||
|
};
|
||||||
|
applied.store(true, SeqCst);
|
||||||
|
let did_apply = TestPlan::apply_server_operation(
|
||||||
|
plan.clone(),
|
||||||
|
deterministic.clone(),
|
||||||
|
&mut server,
|
||||||
|
&mut clients,
|
||||||
|
&mut client_tasks,
|
||||||
|
&mut operation_channels,
|
||||||
|
next_operation,
|
||||||
|
cx,
|
||||||
|
)
|
||||||
|
.await;
|
||||||
|
if !did_apply {
|
||||||
|
applied.store(false, SeqCst);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
drop(operation_channels);
|
||||||
|
deterministic.start_waiting();
|
||||||
|
futures::future::join_all(client_tasks).await;
|
||||||
|
deterministic.finish_waiting();
|
||||||
|
|
||||||
|
deterministic.run_until_parked();
|
||||||
|
T::on_clients_quiesced(&clients);
|
||||||
|
|
||||||
|
for (client, mut cx) in clients {
|
||||||
|
cx.update(|cx| {
|
||||||
|
let store = cx.remove_global::<SettingsStore>();
|
||||||
|
cx.clear_globals();
|
||||||
|
cx.set_global(store);
|
||||||
|
drop(client);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
deterministic.run_until_parked();
|
||||||
|
|
||||||
|
if let Some(path) = &*PLAN_SAVE_PATH {
|
||||||
|
eprintln!("saved test plan to path {:?}", path);
|
||||||
|
std::fs::write(path, plan.lock().serialize()).unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn save_randomized_test_plan() {
|
||||||
|
if let Some(serialize_plan) = LAST_PLAN.lock().take() {
|
||||||
|
if let Some(path) = &*PLAN_SAVE_PATH {
|
||||||
|
eprintln!("saved test plan to path {:?}", path);
|
||||||
|
std::fs::write(path, serialize_plan()).unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T: RandomizedTest> TestPlan<T> {
|
||||||
|
pub async fn new(db: Arc<Database>, mut rng: StdRng) -> Arc<Mutex<Self>> {
|
||||||
|
let allow_server_restarts = rng.gen_bool(0.7);
|
||||||
|
let allow_client_reconnection = rng.gen_bool(0.7);
|
||||||
|
let allow_client_disconnection = rng.gen_bool(0.1);
|
||||||
|
|
||||||
|
let mut users = Vec::new();
|
||||||
|
for ix in 0..*MAX_PEERS {
|
||||||
|
let username = format!("user-{}", ix + 1);
|
||||||
|
let user_id = db
|
||||||
|
.create_user(
|
||||||
|
&format!("{username}@example.com"),
|
||||||
|
false,
|
||||||
|
NewUserParams {
|
||||||
|
github_login: username.clone(),
|
||||||
|
github_user_id: (ix + 1) as i32,
|
||||||
|
invite_count: 0,
|
||||||
|
},
|
||||||
|
)
|
||||||
|
.await
|
||||||
|
.unwrap()
|
||||||
|
.user_id;
|
||||||
|
users.push(UserTestPlan {
|
||||||
|
user_id,
|
||||||
|
username,
|
||||||
|
online: false,
|
||||||
|
next_root_id: 0,
|
||||||
|
operation_ix: 0,
|
||||||
|
allow_client_disconnection,
|
||||||
|
allow_client_reconnection,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
for (ix, user_a) in users.iter().enumerate() {
|
||||||
|
for user_b in &users[ix + 1..] {
|
||||||
|
db.send_contact_request(user_a.user_id, user_b.user_id)
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
db.respond_to_contact_request(user_b.user_id, user_a.user_id, true)
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let plan = Arc::new(Mutex::new(Self {
|
||||||
|
replay: false,
|
||||||
|
allow_server_restarts,
|
||||||
|
allow_client_reconnection,
|
||||||
|
allow_client_disconnection,
|
||||||
|
stored_operations: Vec::new(),
|
||||||
|
operation_ix: 0,
|
||||||
|
next_batch_id: 0,
|
||||||
|
max_operations: *MAX_OPERATIONS,
|
||||||
|
users,
|
||||||
|
rng,
|
||||||
|
}));
|
||||||
|
|
||||||
|
if let Some(path) = &*PLAN_LOAD_PATH {
|
||||||
|
let json = LOADED_PLAN_JSON
|
||||||
|
.lock()
|
||||||
|
.get_or_insert_with(|| {
|
||||||
|
eprintln!("loaded test plan from path {:?}", path);
|
||||||
|
std::fs::read(path).unwrap()
|
||||||
|
})
|
||||||
|
.clone();
|
||||||
|
plan.lock().deserialize(json);
|
||||||
|
}
|
||||||
|
|
||||||
|
plan
|
||||||
|
}
|
||||||
|
|
||||||
|
fn deserialize(&mut self, json: Vec<u8>) {
|
||||||
|
let stored_operations: Vec<StoredOperation<T::Operation>> =
|
||||||
|
serde_json::from_slice(&json).unwrap();
|
||||||
|
self.replay = true;
|
||||||
|
self.stored_operations = stored_operations
|
||||||
|
.iter()
|
||||||
|
.cloned()
|
||||||
|
.enumerate()
|
||||||
|
.map(|(i, mut operation)| {
|
||||||
|
let did_apply = Arc::new(AtomicBool::new(false));
|
||||||
|
if let StoredOperation::Server(ServerOperation::MutateClients {
|
||||||
|
batch_id: current_batch_id,
|
||||||
|
user_ids,
|
||||||
|
..
|
||||||
|
}) = &mut operation
|
||||||
|
{
|
||||||
|
assert!(user_ids.is_empty());
|
||||||
|
user_ids.extend(stored_operations[i + 1..].iter().filter_map(|operation| {
|
||||||
|
if let StoredOperation::Client {
|
||||||
|
user_id, batch_id, ..
|
||||||
|
} = operation
|
||||||
|
{
|
||||||
|
if batch_id == current_batch_id {
|
||||||
|
return Some(user_id);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
None
|
||||||
|
}));
|
||||||
|
user_ids.sort_unstable();
|
||||||
|
}
|
||||||
|
(operation, did_apply)
|
||||||
|
})
|
||||||
|
.collect()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn serialize(&mut self) -> Vec<u8> {
|
||||||
|
// Format each operation as one line
|
||||||
|
let mut json = Vec::new();
|
||||||
|
json.push(b'[');
|
||||||
|
for (operation, applied) in &self.stored_operations {
|
||||||
|
if !applied.load(SeqCst) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if json.len() > 1 {
|
||||||
|
json.push(b',');
|
||||||
|
}
|
||||||
|
json.extend_from_slice(b"\n ");
|
||||||
|
serde_json::to_writer(&mut json, operation).unwrap();
|
||||||
|
}
|
||||||
|
json.extend_from_slice(b"\n]\n");
|
||||||
|
json
|
||||||
|
}
|
||||||
|
|
||||||
|
fn next_server_operation(
|
||||||
|
&mut self,
|
||||||
|
clients: &[(Rc<TestClient>, TestAppContext)],
|
||||||
|
) -> Option<(ServerOperation, Arc<AtomicBool>)> {
|
||||||
|
if self.replay {
|
||||||
|
while let Some(stored_operation) = self.stored_operations.get(self.operation_ix) {
|
||||||
|
self.operation_ix += 1;
|
||||||
|
if let (StoredOperation::Server(operation), applied) = stored_operation {
|
||||||
|
return Some((operation.clone(), applied.clone()));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
None
|
||||||
|
} else {
|
||||||
|
let operation = self.generate_server_operation(clients)?;
|
||||||
|
let applied = Arc::new(AtomicBool::new(false));
|
||||||
|
self.stored_operations
|
||||||
|
.push((StoredOperation::Server(operation.clone()), applied.clone()));
|
||||||
|
Some((operation, applied))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn next_client_operation(
|
||||||
|
&mut self,
|
||||||
|
client: &TestClient,
|
||||||
|
current_batch_id: usize,
|
||||||
|
cx: &TestAppContext,
|
||||||
|
) -> Option<(T::Operation, Arc<AtomicBool>)> {
|
||||||
|
let current_user_id = client.current_user_id(cx);
|
||||||
|
let user_ix = self
|
||||||
|
.users
|
||||||
|
.iter()
|
||||||
|
.position(|user| user.user_id == current_user_id)
|
||||||
|
.unwrap();
|
||||||
|
let user_plan = &mut self.users[user_ix];
|
||||||
|
|
||||||
|
if self.replay {
|
||||||
|
while let Some(stored_operation) = self.stored_operations.get(user_plan.operation_ix) {
|
||||||
|
user_plan.operation_ix += 1;
|
||||||
|
if let (
|
||||||
|
StoredOperation::Client {
|
||||||
|
user_id, operation, ..
|
||||||
|
},
|
||||||
|
applied,
|
||||||
|
) = stored_operation
|
||||||
|
{
|
||||||
|
if user_id == ¤t_user_id {
|
||||||
|
return Some((operation.clone(), applied.clone()));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
None
|
||||||
|
} else {
|
||||||
|
if self.operation_ix == self.max_operations {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
self.operation_ix += 1;
|
||||||
|
let operation = T::generate_operation(
|
||||||
|
client,
|
||||||
|
&mut self.rng,
|
||||||
|
self.users
|
||||||
|
.iter_mut()
|
||||||
|
.find(|user| user.user_id == current_user_id)
|
||||||
|
.unwrap(),
|
||||||
|
cx,
|
||||||
|
);
|
||||||
|
let applied = Arc::new(AtomicBool::new(false));
|
||||||
|
self.stored_operations.push((
|
||||||
|
StoredOperation::Client {
|
||||||
|
user_id: current_user_id,
|
||||||
|
batch_id: current_batch_id,
|
||||||
|
operation: operation.clone(),
|
||||||
|
},
|
||||||
|
applied.clone(),
|
||||||
|
));
|
||||||
|
Some((operation, applied))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn generate_server_operation(
|
||||||
|
&mut self,
|
||||||
|
clients: &[(Rc<TestClient>, TestAppContext)],
|
||||||
|
) -> Option<ServerOperation> {
|
||||||
|
if self.operation_ix == self.max_operations {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
|
||||||
|
Some(loop {
|
||||||
|
break match self.rng.gen_range(0..100) {
|
||||||
|
0..=29 if clients.len() < self.users.len() => {
|
||||||
|
let user = self
|
||||||
|
.users
|
||||||
|
.iter()
|
||||||
|
.filter(|u| !u.online)
|
||||||
|
.choose(&mut self.rng)
|
||||||
|
.unwrap();
|
||||||
|
self.operation_ix += 1;
|
||||||
|
ServerOperation::AddConnection {
|
||||||
|
user_id: user.user_id,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
30..=34 if clients.len() > 1 && self.allow_client_disconnection => {
|
||||||
|
let (client, cx) = &clients[self.rng.gen_range(0..clients.len())];
|
||||||
|
let user_id = client.current_user_id(cx);
|
||||||
|
self.operation_ix += 1;
|
||||||
|
ServerOperation::RemoveConnection { user_id }
|
||||||
|
}
|
||||||
|
35..=39 if clients.len() > 1 && self.allow_client_reconnection => {
|
||||||
|
let (client, cx) = &clients[self.rng.gen_range(0..clients.len())];
|
||||||
|
let user_id = client.current_user_id(cx);
|
||||||
|
self.operation_ix += 1;
|
||||||
|
ServerOperation::BounceConnection { user_id }
|
||||||
|
}
|
||||||
|
40..=44 if self.allow_server_restarts && clients.len() > 1 => {
|
||||||
|
self.operation_ix += 1;
|
||||||
|
ServerOperation::RestartServer
|
||||||
|
}
|
||||||
|
_ if !clients.is_empty() => {
|
||||||
|
let count = self
|
||||||
|
.rng
|
||||||
|
.gen_range(1..10)
|
||||||
|
.min(self.max_operations - self.operation_ix);
|
||||||
|
let batch_id = util::post_inc(&mut self.next_batch_id);
|
||||||
|
let mut user_ids = (0..count)
|
||||||
|
.map(|_| {
|
||||||
|
let ix = self.rng.gen_range(0..clients.len());
|
||||||
|
let (client, cx) = &clients[ix];
|
||||||
|
client.current_user_id(cx)
|
||||||
|
})
|
||||||
|
.collect::<Vec<_>>();
|
||||||
|
user_ids.sort_unstable();
|
||||||
|
ServerOperation::MutateClients {
|
||||||
|
user_ids,
|
||||||
|
batch_id,
|
||||||
|
quiesce: self.rng.gen_bool(0.7),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_ => continue,
|
||||||
|
};
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn apply_server_operation(
|
||||||
|
plan: Arc<Mutex<Self>>,
|
||||||
|
deterministic: Arc<Deterministic>,
|
||||||
|
server: &mut TestServer,
|
||||||
|
clients: &mut Vec<(Rc<TestClient>, TestAppContext)>,
|
||||||
|
client_tasks: &mut Vec<Task<()>>,
|
||||||
|
operation_channels: &mut Vec<futures::channel::mpsc::UnboundedSender<usize>>,
|
||||||
|
operation: ServerOperation,
|
||||||
|
cx: &mut TestAppContext,
|
||||||
|
) -> bool {
|
||||||
|
match operation {
|
||||||
|
ServerOperation::AddConnection { user_id } => {
|
||||||
|
let username;
|
||||||
|
{
|
||||||
|
let mut plan = plan.lock();
|
||||||
|
let user = plan.user(user_id);
|
||||||
|
if user.online {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
user.online = true;
|
||||||
|
username = user.username.clone();
|
||||||
|
};
|
||||||
|
log::info!("adding new connection for {}", username);
|
||||||
|
let next_entity_id = (user_id.0 * 10_000) as usize;
|
||||||
|
let mut client_cx = TestAppContext::new(
|
||||||
|
cx.foreground_platform(),
|
||||||
|
cx.platform(),
|
||||||
|
deterministic.build_foreground(user_id.0 as usize),
|
||||||
|
deterministic.build_background(),
|
||||||
|
cx.font_cache(),
|
||||||
|
cx.leak_detector(),
|
||||||
|
next_entity_id,
|
||||||
|
cx.function_name.clone(),
|
||||||
|
);
|
||||||
|
|
||||||
|
let (operation_tx, operation_rx) = futures::channel::mpsc::unbounded();
|
||||||
|
let client = Rc::new(server.create_client(&mut client_cx, &username).await);
|
||||||
|
operation_channels.push(operation_tx);
|
||||||
|
clients.push((client.clone(), client_cx.clone()));
|
||||||
|
client_tasks.push(client_cx.foreground().spawn(Self::simulate_client(
|
||||||
|
plan.clone(),
|
||||||
|
client,
|
||||||
|
operation_rx,
|
||||||
|
client_cx,
|
||||||
|
)));
|
||||||
|
|
||||||
|
log::info!("added connection for {}", username);
|
||||||
|
}
|
||||||
|
|
||||||
|
ServerOperation::RemoveConnection {
|
||||||
|
user_id: removed_user_id,
|
||||||
|
} => {
|
||||||
|
log::info!("simulating full disconnection of user {}", removed_user_id);
|
||||||
|
let client_ix = clients
|
||||||
|
.iter()
|
||||||
|
.position(|(client, cx)| client.current_user_id(cx) == removed_user_id);
|
||||||
|
let Some(client_ix) = client_ix else {
|
||||||
|
return false;
|
||||||
|
};
|
||||||
|
let user_connection_ids = server
|
||||||
|
.connection_pool
|
||||||
|
.lock()
|
||||||
|
.user_connection_ids(removed_user_id)
|
||||||
|
.collect::<Vec<_>>();
|
||||||
|
assert_eq!(user_connection_ids.len(), 1);
|
||||||
|
let removed_peer_id = user_connection_ids[0].into();
|
||||||
|
let (client, mut client_cx) = clients.remove(client_ix);
|
||||||
|
let client_task = client_tasks.remove(client_ix);
|
||||||
|
operation_channels.remove(client_ix);
|
||||||
|
server.forbid_connections();
|
||||||
|
server.disconnect_client(removed_peer_id);
|
||||||
|
deterministic.advance_clock(RECEIVE_TIMEOUT + RECONNECT_TIMEOUT);
|
||||||
|
deterministic.start_waiting();
|
||||||
|
log::info!("waiting for user {} to exit...", removed_user_id);
|
||||||
|
client_task.await;
|
||||||
|
deterministic.finish_waiting();
|
||||||
|
server.allow_connections();
|
||||||
|
|
||||||
|
for project in client.remote_projects().iter() {
|
||||||
|
project.read_with(&client_cx, |project, _| {
|
||||||
|
assert!(
|
||||||
|
project.is_read_only(),
|
||||||
|
"project {:?} should be read only",
|
||||||
|
project.remote_id()
|
||||||
|
)
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
for (client, cx) in clients {
|
||||||
|
let contacts = server
|
||||||
|
.app_state
|
||||||
|
.db
|
||||||
|
.get_contacts(client.current_user_id(cx))
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
let pool = server.connection_pool.lock();
|
||||||
|
for contact in contacts {
|
||||||
|
if let db::Contact::Accepted { user_id, busy, .. } = contact {
|
||||||
|
if user_id == removed_user_id {
|
||||||
|
assert!(!pool.is_user_online(user_id));
|
||||||
|
assert!(!busy);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
log::info!("{} removed", client.username);
|
||||||
|
plan.lock().user(removed_user_id).online = false;
|
||||||
|
client_cx.update(|cx| {
|
||||||
|
cx.clear_globals();
|
||||||
|
drop(client);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
ServerOperation::BounceConnection { user_id } => {
|
||||||
|
log::info!("simulating temporary disconnection of user {}", user_id);
|
||||||
|
let user_connection_ids = server
|
||||||
|
.connection_pool
|
||||||
|
.lock()
|
||||||
|
.user_connection_ids(user_id)
|
||||||
|
.collect::<Vec<_>>();
|
||||||
|
if user_connection_ids.is_empty() {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
assert_eq!(user_connection_ids.len(), 1);
|
||||||
|
let peer_id = user_connection_ids[0].into();
|
||||||
|
server.disconnect_client(peer_id);
|
||||||
|
deterministic.advance_clock(RECEIVE_TIMEOUT + RECONNECT_TIMEOUT);
|
||||||
|
}
|
||||||
|
|
||||||
|
ServerOperation::RestartServer => {
|
||||||
|
log::info!("simulating server restart");
|
||||||
|
server.reset().await;
|
||||||
|
deterministic.advance_clock(RECEIVE_TIMEOUT);
|
||||||
|
server.start().await.unwrap();
|
||||||
|
deterministic.advance_clock(CLEANUP_TIMEOUT);
|
||||||
|
let environment = &server.app_state.config.zed_environment;
|
||||||
|
let (stale_room_ids, _) = server
|
||||||
|
.app_state
|
||||||
|
.db
|
||||||
|
.stale_server_resource_ids(environment, server.id())
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
assert_eq!(stale_room_ids, vec![]);
|
||||||
|
}
|
||||||
|
|
||||||
|
ServerOperation::MutateClients {
|
||||||
|
user_ids,
|
||||||
|
batch_id,
|
||||||
|
quiesce,
|
||||||
|
} => {
|
||||||
|
let mut applied = false;
|
||||||
|
for user_id in user_ids {
|
||||||
|
let client_ix = clients
|
||||||
|
.iter()
|
||||||
|
.position(|(client, cx)| client.current_user_id(cx) == user_id);
|
||||||
|
let Some(client_ix) = client_ix else { continue };
|
||||||
|
applied = true;
|
||||||
|
if let Err(err) = operation_channels[client_ix].unbounded_send(batch_id) {
|
||||||
|
log::error!("error signaling user {user_id}: {err}");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if quiesce && applied {
|
||||||
|
deterministic.run_until_parked();
|
||||||
|
T::on_clients_quiesced(&clients);
|
||||||
|
}
|
||||||
|
|
||||||
|
return applied;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
true
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn simulate_client(
|
||||||
|
plan: Arc<Mutex<Self>>,
|
||||||
|
client: Rc<TestClient>,
|
||||||
|
mut operation_rx: futures::channel::mpsc::UnboundedReceiver<usize>,
|
||||||
|
mut cx: TestAppContext,
|
||||||
|
) {
|
||||||
|
T::on_client_added(&client).await;
|
||||||
|
|
||||||
|
while let Some(batch_id) = operation_rx.next().await {
|
||||||
|
let Some((operation, applied)) =
|
||||||
|
plan.lock().next_client_operation(&client, batch_id, &cx)
|
||||||
|
else {
|
||||||
|
break;
|
||||||
|
};
|
||||||
|
applied.store(true, SeqCst);
|
||||||
|
match T::apply_operation(&client, operation, &mut cx).await {
|
||||||
|
Ok(()) => {}
|
||||||
|
Err(TestError::Inapplicable) => {
|
||||||
|
applied.store(false, SeqCst);
|
||||||
|
log::info!("skipped operation");
|
||||||
|
}
|
||||||
|
Err(TestError::Other(error)) => {
|
||||||
|
log::error!("{} error: {}", client.username, error);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
cx.background().simulate_random_delay().await;
|
||||||
|
}
|
||||||
|
log::info!("{}: done", client.username);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn user(&mut self, user_id: UserId) -> &mut UserTestPlan {
|
||||||
|
self.users
|
||||||
|
.iter_mut()
|
||||||
|
.find(|user| user.user_id == user_id)
|
||||||
|
.unwrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl UserTestPlan {
|
||||||
|
pub fn next_root_dir_name(&mut self) -> String {
|
||||||
|
let user_id = self.user_id;
|
||||||
|
let root_id = util::post_inc(&mut self.next_root_id);
|
||||||
|
format!("dir-{user_id}-{root_id}")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<anyhow::Error> for TestError {
|
||||||
|
fn from(value: anyhow::Error) -> Self {
|
||||||
|
Self::Other(value)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn path_env_var(name: &str) -> Option<PathBuf> {
|
||||||
|
let value = env::var(name).ok()?;
|
||||||
|
let mut path = PathBuf::from(value);
|
||||||
|
if path.is_relative() {
|
||||||
|
let mut abs_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
|
||||||
|
abs_path.pop();
|
||||||
|
abs_path.pop();
|
||||||
|
abs_path.push(path);
|
||||||
|
path = abs_path
|
||||||
|
}
|
||||||
|
Some(path)
|
||||||
|
}
|
551
crates/collab/src/tests/test_server.rs
Normal file
551
crates/collab/src/tests/test_server.rs
Normal file
@ -0,0 +1,551 @@
|
|||||||
|
use crate::{
|
||||||
|
db::{tests::TestDb, NewUserParams, UserId},
|
||||||
|
executor::Executor,
|
||||||
|
rpc::{Server, CLEANUP_TIMEOUT},
|
||||||
|
AppState,
|
||||||
|
};
|
||||||
|
use anyhow::anyhow;
|
||||||
|
use call::ActiveCall;
|
||||||
|
use channel::ChannelStore;
|
||||||
|
use client::{
|
||||||
|
self, proto::PeerId, Client, Connection, Credentials, EstablishConnectionError, UserStore,
|
||||||
|
};
|
||||||
|
use collections::{HashMap, HashSet};
|
||||||
|
use fs::FakeFs;
|
||||||
|
use futures::{channel::oneshot, StreamExt as _};
|
||||||
|
use gpui::{executor::Deterministic, ModelHandle, Task, TestAppContext, WindowHandle};
|
||||||
|
use language::LanguageRegistry;
|
||||||
|
use parking_lot::Mutex;
|
||||||
|
use project::{Project, WorktreeId};
|
||||||
|
use settings::SettingsStore;
|
||||||
|
use std::{
|
||||||
|
cell::{Ref, RefCell, RefMut},
|
||||||
|
env,
|
||||||
|
ops::{Deref, DerefMut},
|
||||||
|
path::Path,
|
||||||
|
sync::{
|
||||||
|
atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst},
|
||||||
|
Arc,
|
||||||
|
},
|
||||||
|
};
|
||||||
|
use util::http::FakeHttpClient;
|
||||||
|
use workspace::Workspace;
|
||||||
|
|
||||||
|
pub struct TestServer {
|
||||||
|
pub app_state: Arc<AppState>,
|
||||||
|
pub test_live_kit_server: Arc<live_kit_client::TestServer>,
|
||||||
|
server: Arc<Server>,
|
||||||
|
connection_killers: Arc<Mutex<HashMap<PeerId, Arc<AtomicBool>>>>,
|
||||||
|
forbid_connections: Arc<AtomicBool>,
|
||||||
|
_test_db: TestDb,
|
||||||
|
}
|
||||||
|
|
||||||
|
pub struct TestClient {
|
||||||
|
pub username: String,
|
||||||
|
pub app_state: Arc<workspace::AppState>,
|
||||||
|
state: RefCell<TestClientState>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Default)]
|
||||||
|
struct TestClientState {
|
||||||
|
local_projects: Vec<ModelHandle<Project>>,
|
||||||
|
remote_projects: Vec<ModelHandle<Project>>,
|
||||||
|
buffers: HashMap<ModelHandle<Project>, HashSet<ModelHandle<language::Buffer>>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
pub struct ContactsSummary {
|
||||||
|
pub current: Vec<String>,
|
||||||
|
pub outgoing_requests: Vec<String>,
|
||||||
|
pub incoming_requests: Vec<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TestServer {
|
||||||
|
pub async fn start(deterministic: &Arc<Deterministic>) -> Self {
|
||||||
|
static NEXT_LIVE_KIT_SERVER_ID: AtomicUsize = AtomicUsize::new(0);
|
||||||
|
|
||||||
|
let use_postgres = env::var("USE_POSTGRES").ok();
|
||||||
|
let use_postgres = use_postgres.as_deref();
|
||||||
|
let test_db = if use_postgres == Some("true") || use_postgres == Some("1") {
|
||||||
|
TestDb::postgres(deterministic.build_background())
|
||||||
|
} else {
|
||||||
|
TestDb::sqlite(deterministic.build_background())
|
||||||
|
};
|
||||||
|
let live_kit_server_id = NEXT_LIVE_KIT_SERVER_ID.fetch_add(1, SeqCst);
|
||||||
|
let live_kit_server = live_kit_client::TestServer::create(
|
||||||
|
format!("http://livekit.{}.test", live_kit_server_id),
|
||||||
|
format!("devkey-{}", live_kit_server_id),
|
||||||
|
format!("secret-{}", live_kit_server_id),
|
||||||
|
deterministic.build_background(),
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let app_state = Self::build_app_state(&test_db, &live_kit_server).await;
|
||||||
|
let epoch = app_state
|
||||||
|
.db
|
||||||
|
.create_server(&app_state.config.zed_environment)
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
let server = Server::new(
|
||||||
|
epoch,
|
||||||
|
app_state.clone(),
|
||||||
|
Executor::Deterministic(deterministic.build_background()),
|
||||||
|
);
|
||||||
|
server.start().await.unwrap();
|
||||||
|
// Advance clock to ensure the server's cleanup task is finished.
|
||||||
|
deterministic.advance_clock(CLEANUP_TIMEOUT);
|
||||||
|
Self {
|
||||||
|
app_state,
|
||||||
|
server,
|
||||||
|
connection_killers: Default::default(),
|
||||||
|
forbid_connections: Default::default(),
|
||||||
|
_test_db: test_db,
|
||||||
|
test_live_kit_server: live_kit_server,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn reset(&self) {
|
||||||
|
self.app_state.db.reset();
|
||||||
|
let epoch = self
|
||||||
|
.app_state
|
||||||
|
.db
|
||||||
|
.create_server(&self.app_state.config.zed_environment)
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
self.server.reset(epoch);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn create_client(&mut self, cx: &mut TestAppContext, name: &str) -> TestClient {
|
||||||
|
cx.update(|cx| {
|
||||||
|
if cx.has_global::<SettingsStore>() {
|
||||||
|
panic!("Same cx used to create two test clients")
|
||||||
|
}
|
||||||
|
cx.set_global(SettingsStore::test(cx));
|
||||||
|
});
|
||||||
|
|
||||||
|
let http = FakeHttpClient::with_404_response();
|
||||||
|
let user_id = if let Ok(Some(user)) = self.app_state.db.get_user_by_github_login(name).await
|
||||||
|
{
|
||||||
|
user.id
|
||||||
|
} else {
|
||||||
|
self.app_state
|
||||||
|
.db
|
||||||
|
.create_user(
|
||||||
|
&format!("{name}@example.com"),
|
||||||
|
false,
|
||||||
|
NewUserParams {
|
||||||
|
github_login: name.into(),
|
||||||
|
github_user_id: 0,
|
||||||
|
invite_count: 0,
|
||||||
|
},
|
||||||
|
)
|
||||||
|
.await
|
||||||
|
.expect("creating user failed")
|
||||||
|
.user_id
|
||||||
|
};
|
||||||
|
let client_name = name.to_string();
|
||||||
|
let mut client = cx.read(|cx| Client::new(http.clone(), cx));
|
||||||
|
let server = self.server.clone();
|
||||||
|
let db = self.app_state.db.clone();
|
||||||
|
let connection_killers = self.connection_killers.clone();
|
||||||
|
let forbid_connections = self.forbid_connections.clone();
|
||||||
|
|
||||||
|
Arc::get_mut(&mut client)
|
||||||
|
.unwrap()
|
||||||
|
.set_id(user_id.0 as usize)
|
||||||
|
.override_authenticate(move |cx| {
|
||||||
|
cx.spawn(|_| async move {
|
||||||
|
let access_token = "the-token".to_string();
|
||||||
|
Ok(Credentials {
|
||||||
|
user_id: user_id.0 as u64,
|
||||||
|
access_token,
|
||||||
|
})
|
||||||
|
})
|
||||||
|
})
|
||||||
|
.override_establish_connection(move |credentials, cx| {
|
||||||
|
assert_eq!(credentials.user_id, user_id.0 as u64);
|
||||||
|
assert_eq!(credentials.access_token, "the-token");
|
||||||
|
|
||||||
|
let server = server.clone();
|
||||||
|
let db = db.clone();
|
||||||
|
let connection_killers = connection_killers.clone();
|
||||||
|
let forbid_connections = forbid_connections.clone();
|
||||||
|
let client_name = client_name.clone();
|
||||||
|
cx.spawn(move |cx| async move {
|
||||||
|
if forbid_connections.load(SeqCst) {
|
||||||
|
Err(EstablishConnectionError::other(anyhow!(
|
||||||
|
"server is forbidding connections"
|
||||||
|
)))
|
||||||
|
} else {
|
||||||
|
let (client_conn, server_conn, killed) =
|
||||||
|
Connection::in_memory(cx.background());
|
||||||
|
let (connection_id_tx, connection_id_rx) = oneshot::channel();
|
||||||
|
let user = db
|
||||||
|
.get_user_by_id(user_id)
|
||||||
|
.await
|
||||||
|
.expect("retrieving user failed")
|
||||||
|
.unwrap();
|
||||||
|
cx.background()
|
||||||
|
.spawn(server.handle_connection(
|
||||||
|
server_conn,
|
||||||
|
client_name,
|
||||||
|
user,
|
||||||
|
Some(connection_id_tx),
|
||||||
|
Executor::Deterministic(cx.background()),
|
||||||
|
))
|
||||||
|
.detach();
|
||||||
|
let connection_id = connection_id_rx.await.unwrap();
|
||||||
|
connection_killers
|
||||||
|
.lock()
|
||||||
|
.insert(connection_id.into(), killed);
|
||||||
|
Ok(client_conn)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
});
|
||||||
|
|
||||||
|
let fs = FakeFs::new(cx.background());
|
||||||
|
let user_store = cx.add_model(|cx| UserStore::new(client.clone(), http, cx));
|
||||||
|
let channel_store =
|
||||||
|
cx.add_model(|cx| ChannelStore::new(client.clone(), user_store.clone(), cx));
|
||||||
|
let app_state = Arc::new(workspace::AppState {
|
||||||
|
client: client.clone(),
|
||||||
|
user_store: user_store.clone(),
|
||||||
|
channel_store: channel_store.clone(),
|
||||||
|
languages: Arc::new(LanguageRegistry::test()),
|
||||||
|
fs: fs.clone(),
|
||||||
|
build_window_options: |_, _, _| Default::default(),
|
||||||
|
initialize_workspace: |_, _, _, _| Task::ready(Ok(())),
|
||||||
|
background_actions: || &[],
|
||||||
|
});
|
||||||
|
|
||||||
|
cx.update(|cx| {
|
||||||
|
theme::init((), cx);
|
||||||
|
Project::init(&client, cx);
|
||||||
|
client::init(&client, cx);
|
||||||
|
language::init(cx);
|
||||||
|
editor::init_settings(cx);
|
||||||
|
workspace::init(app_state.clone(), cx);
|
||||||
|
audio::init((), cx);
|
||||||
|
call::init(client.clone(), user_store.clone(), cx);
|
||||||
|
channel::init(&client);
|
||||||
|
});
|
||||||
|
|
||||||
|
client
|
||||||
|
.authenticate_and_connect(false, &cx.to_async())
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let client = TestClient {
|
||||||
|
app_state,
|
||||||
|
username: name.to_string(),
|
||||||
|
state: Default::default(),
|
||||||
|
};
|
||||||
|
client.wait_for_current_user(cx).await;
|
||||||
|
client
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn disconnect_client(&self, peer_id: PeerId) {
|
||||||
|
self.connection_killers
|
||||||
|
.lock()
|
||||||
|
.remove(&peer_id)
|
||||||
|
.unwrap()
|
||||||
|
.store(true, SeqCst);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn forbid_connections(&self) {
|
||||||
|
self.forbid_connections.store(true, SeqCst);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn allow_connections(&self) {
|
||||||
|
self.forbid_connections.store(false, SeqCst);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn make_contacts(&self, clients: &mut [(&TestClient, &mut TestAppContext)]) {
|
||||||
|
for ix in 1..clients.len() {
|
||||||
|
let (left, right) = clients.split_at_mut(ix);
|
||||||
|
let (client_a, cx_a) = left.last_mut().unwrap();
|
||||||
|
for (client_b, cx_b) in right {
|
||||||
|
client_a
|
||||||
|
.app_state
|
||||||
|
.user_store
|
||||||
|
.update(*cx_a, |store, cx| {
|
||||||
|
store.request_contact(client_b.user_id().unwrap(), cx)
|
||||||
|
})
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
cx_a.foreground().run_until_parked();
|
||||||
|
client_b
|
||||||
|
.app_state
|
||||||
|
.user_store
|
||||||
|
.update(*cx_b, |store, cx| {
|
||||||
|
store.respond_to_contact_request(client_a.user_id().unwrap(), true, cx)
|
||||||
|
})
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn make_channel(
|
||||||
|
&self,
|
||||||
|
channel: &str,
|
||||||
|
admin: (&TestClient, &mut TestAppContext),
|
||||||
|
members: &mut [(&TestClient, &mut TestAppContext)],
|
||||||
|
) -> u64 {
|
||||||
|
let (admin_client, admin_cx) = admin;
|
||||||
|
let channel_id = admin_client
|
||||||
|
.app_state
|
||||||
|
.channel_store
|
||||||
|
.update(admin_cx, |channel_store, cx| {
|
||||||
|
channel_store.create_channel(channel, None, cx)
|
||||||
|
})
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
for (member_client, member_cx) in members {
|
||||||
|
admin_client
|
||||||
|
.app_state
|
||||||
|
.channel_store
|
||||||
|
.update(admin_cx, |channel_store, cx| {
|
||||||
|
channel_store.invite_member(
|
||||||
|
channel_id,
|
||||||
|
member_client.user_id().unwrap(),
|
||||||
|
false,
|
||||||
|
cx,
|
||||||
|
)
|
||||||
|
})
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
admin_cx.foreground().run_until_parked();
|
||||||
|
|
||||||
|
member_client
|
||||||
|
.app_state
|
||||||
|
.channel_store
|
||||||
|
.update(*member_cx, |channels, _| {
|
||||||
|
channels.respond_to_channel_invite(channel_id, true)
|
||||||
|
})
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
channel_id
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn create_room(&self, clients: &mut [(&TestClient, &mut TestAppContext)]) {
|
||||||
|
self.make_contacts(clients).await;
|
||||||
|
|
||||||
|
let (left, right) = clients.split_at_mut(1);
|
||||||
|
let (_client_a, cx_a) = &mut left[0];
|
||||||
|
let active_call_a = cx_a.read(ActiveCall::global);
|
||||||
|
|
||||||
|
for (client_b, cx_b) in right {
|
||||||
|
let user_id_b = client_b.current_user_id(*cx_b).to_proto();
|
||||||
|
active_call_a
|
||||||
|
.update(*cx_a, |call, cx| call.invite(user_id_b, None, cx))
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
cx_b.foreground().run_until_parked();
|
||||||
|
let active_call_b = cx_b.read(ActiveCall::global);
|
||||||
|
active_call_b
|
||||||
|
.update(*cx_b, |call, cx| call.accept_incoming(cx))
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn build_app_state(
|
||||||
|
test_db: &TestDb,
|
||||||
|
fake_server: &live_kit_client::TestServer,
|
||||||
|
) -> Arc<AppState> {
|
||||||
|
Arc::new(AppState {
|
||||||
|
db: test_db.db().clone(),
|
||||||
|
live_kit_client: Some(Arc::new(fake_server.create_api_client())),
|
||||||
|
config: Default::default(),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Deref for TestServer {
|
||||||
|
type Target = Server;
|
||||||
|
|
||||||
|
fn deref(&self) -> &Self::Target {
|
||||||
|
&self.server
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Drop for TestServer {
|
||||||
|
fn drop(&mut self) {
|
||||||
|
self.server.teardown();
|
||||||
|
self.test_live_kit_server.teardown().unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Deref for TestClient {
|
||||||
|
type Target = Arc<Client>;
|
||||||
|
|
||||||
|
fn deref(&self) -> &Self::Target {
|
||||||
|
&self.app_state.client
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TestClient {
|
||||||
|
pub fn fs(&self) -> &FakeFs {
|
||||||
|
self.app_state.fs.as_fake()
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn channel_store(&self) -> &ModelHandle<ChannelStore> {
|
||||||
|
&self.app_state.channel_store
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn user_store(&self) -> &ModelHandle<UserStore> {
|
||||||
|
&self.app_state.user_store
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn language_registry(&self) -> &Arc<LanguageRegistry> {
|
||||||
|
&self.app_state.languages
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn client(&self) -> &Arc<Client> {
|
||||||
|
&self.app_state.client
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn current_user_id(&self, cx: &TestAppContext) -> UserId {
|
||||||
|
UserId::from_proto(
|
||||||
|
self.app_state
|
||||||
|
.user_store
|
||||||
|
.read_with(cx, |user_store, _| user_store.current_user().unwrap().id),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn wait_for_current_user(&self, cx: &TestAppContext) {
|
||||||
|
let mut authed_user = self
|
||||||
|
.app_state
|
||||||
|
.user_store
|
||||||
|
.read_with(cx, |user_store, _| user_store.watch_current_user());
|
||||||
|
while authed_user.next().await.unwrap().is_none() {}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn clear_contacts(&self, cx: &mut TestAppContext) {
|
||||||
|
self.app_state
|
||||||
|
.user_store
|
||||||
|
.update(cx, |store, _| store.clear_contacts())
|
||||||
|
.await;
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn local_projects<'a>(&'a self) -> impl Deref<Target = Vec<ModelHandle<Project>>> + 'a {
|
||||||
|
Ref::map(self.state.borrow(), |state| &state.local_projects)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn remote_projects<'a>(&'a self) -> impl Deref<Target = Vec<ModelHandle<Project>>> + 'a {
|
||||||
|
Ref::map(self.state.borrow(), |state| &state.remote_projects)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn local_projects_mut<'a>(
|
||||||
|
&'a self,
|
||||||
|
) -> impl DerefMut<Target = Vec<ModelHandle<Project>>> + 'a {
|
||||||
|
RefMut::map(self.state.borrow_mut(), |state| &mut state.local_projects)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn remote_projects_mut<'a>(
|
||||||
|
&'a self,
|
||||||
|
) -> impl DerefMut<Target = Vec<ModelHandle<Project>>> + 'a {
|
||||||
|
RefMut::map(self.state.borrow_mut(), |state| &mut state.remote_projects)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn buffers_for_project<'a>(
|
||||||
|
&'a self,
|
||||||
|
project: &ModelHandle<Project>,
|
||||||
|
) -> impl DerefMut<Target = HashSet<ModelHandle<language::Buffer>>> + 'a {
|
||||||
|
RefMut::map(self.state.borrow_mut(), |state| {
|
||||||
|
state.buffers.entry(project.clone()).or_default()
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn buffers<'a>(
|
||||||
|
&'a self,
|
||||||
|
) -> impl DerefMut<Target = HashMap<ModelHandle<Project>, HashSet<ModelHandle<language::Buffer>>>> + 'a
|
||||||
|
{
|
||||||
|
RefMut::map(self.state.borrow_mut(), |state| &mut state.buffers)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn summarize_contacts(&self, cx: &TestAppContext) -> ContactsSummary {
|
||||||
|
self.app_state
|
||||||
|
.user_store
|
||||||
|
.read_with(cx, |store, _| ContactsSummary {
|
||||||
|
current: store
|
||||||
|
.contacts()
|
||||||
|
.iter()
|
||||||
|
.map(|contact| contact.user.github_login.clone())
|
||||||
|
.collect(),
|
||||||
|
outgoing_requests: store
|
||||||
|
.outgoing_contact_requests()
|
||||||
|
.iter()
|
||||||
|
.map(|user| user.github_login.clone())
|
||||||
|
.collect(),
|
||||||
|
incoming_requests: store
|
||||||
|
.incoming_contact_requests()
|
||||||
|
.iter()
|
||||||
|
.map(|user| user.github_login.clone())
|
||||||
|
.collect(),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn build_local_project(
|
||||||
|
&self,
|
||||||
|
root_path: impl AsRef<Path>,
|
||||||
|
cx: &mut TestAppContext,
|
||||||
|
) -> (ModelHandle<Project>, WorktreeId) {
|
||||||
|
let project = cx.update(|cx| {
|
||||||
|
Project::local(
|
||||||
|
self.client().clone(),
|
||||||
|
self.app_state.user_store.clone(),
|
||||||
|
self.app_state.languages.clone(),
|
||||||
|
self.app_state.fs.clone(),
|
||||||
|
cx,
|
||||||
|
)
|
||||||
|
});
|
||||||
|
let (worktree, _) = project
|
||||||
|
.update(cx, |p, cx| {
|
||||||
|
p.find_or_create_local_worktree(root_path, true, cx)
|
||||||
|
})
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
worktree
|
||||||
|
.read_with(cx, |tree, _| tree.as_local().unwrap().scan_complete())
|
||||||
|
.await;
|
||||||
|
(project, worktree.read_with(cx, |tree, _| tree.id()))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn build_remote_project(
|
||||||
|
&self,
|
||||||
|
host_project_id: u64,
|
||||||
|
guest_cx: &mut TestAppContext,
|
||||||
|
) -> ModelHandle<Project> {
|
||||||
|
let active_call = guest_cx.read(ActiveCall::global);
|
||||||
|
let room = active_call.read_with(guest_cx, |call, _| call.room().unwrap().clone());
|
||||||
|
room.update(guest_cx, |room, cx| {
|
||||||
|
room.join_project(
|
||||||
|
host_project_id,
|
||||||
|
self.app_state.languages.clone(),
|
||||||
|
self.app_state.fs.clone(),
|
||||||
|
cx,
|
||||||
|
)
|
||||||
|
})
|
||||||
|
.await
|
||||||
|
.unwrap()
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn build_workspace(
|
||||||
|
&self,
|
||||||
|
project: &ModelHandle<Project>,
|
||||||
|
cx: &mut TestAppContext,
|
||||||
|
) -> WindowHandle<Workspace> {
|
||||||
|
cx.add_window(|cx| Workspace::new(0, project.clone(), self.app_state.clone(), cx))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Drop for TestClient {
|
||||||
|
fn drop(&mut self) {
|
||||||
|
self.app_state.client.teardown();
|
||||||
|
}
|
||||||
|
}
|
@ -37,8 +37,14 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
|
|||||||
Some("seed") => starting_seed = parse_int(&meta.lit)?,
|
Some("seed") => starting_seed = parse_int(&meta.lit)?,
|
||||||
Some("on_failure") => {
|
Some("on_failure") => {
|
||||||
if let Lit::Str(name) = meta.lit {
|
if let Lit::Str(name) = meta.lit {
|
||||||
let ident = Ident::new(&name.value(), name.span());
|
let mut path = syn::Path {
|
||||||
on_failure_fn_name = quote!(Some(#ident));
|
leading_colon: None,
|
||||||
|
segments: Default::default(),
|
||||||
|
};
|
||||||
|
for part in name.value().split("::") {
|
||||||
|
path.segments.push(Ident::new(part, name.span()).into());
|
||||||
|
}
|
||||||
|
on_failure_fn_name = quote!(Some(#path));
|
||||||
} else {
|
} else {
|
||||||
return Err(TokenStream::from(
|
return Err(TokenStream::from(
|
||||||
syn::Error::new(
|
syn::Error::new(
|
||||||
|
Loading…
Reference in New Issue
Block a user