mirrors/zed
1
0
Fork 0
mirror of https://github.com/zed-industries/zed.git synced 2024-12-31 21:36:26 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 10

Add failing integration test for resharing projects on reconnect

Browse source
This commit is contained in:
Max Brunsfeld 2022-12-16 16:24:42 -08:00
parent 0ede89d82a
commit 67b265b3d5
1 changed files with 93 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

94
crates/collab/src/integration_tests.rs
View file

@ -15,7 +15,7 @@ use editor::{
self, ConfirmCodeAction, ConfirmCompletion, ConfirmRename, Editor, ExcerptRange, MultiBuffer,
Redo, Rename, ToOffset, ToggleCodeActions, Undo,
};
use fs::{FakeFs, Fs as _, HomeDir, LineEnding};
use fs::{FakeFs, Fs as _, HomeDir, LineEnding, RemoveOptions};
use futures::{channel::oneshot, StreamExt as _};
use gpui::{
executor::Deterministic, geometry::vector::vec2f, test::EmptyView, ModelHandle, Task,
@ -1306,6 +1306,98 @@ async fn test_host_disconnect(
project_a.read_with(cx_a, |project, _| assert!(!project.is_shared()));
}
#[gpui::test(iterations = 10)]
async fn test_host_reconnect(
deterministic: Arc<Deterministic>,
cx_a: &mut TestAppContext,
cx_b: &mut TestAppContext,
) {
cx_b.update(editor::init);
deterministic.forbid_parking();
let mut server = TestServer::start(&deterministic).await;
let client_a = server.create_client(cx_a, "user_a").await;
let client_b = server.create_client(cx_b, "user_b").await;
server
.create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
.await;
client_a
.fs
.insert_tree(
"/root",
json!({
"dir1": {
"a.txt": "a-contents",
"b.txt": "b-contents",
"subdir1": {
"c.txt": "c-contents",
"d.txt": "d-contents",
"e.txt": "e-contents",
}
},
"dir2": {
"x.txt": "x-contents",
},
}),
)
.await;
let active_call_a = cx_a.read(ActiveCall::global);
let (project_a, _) = client_a.build_local_project("/root/dir1", cx_a).await;
let worktree_a = project_a.read_with(cx_a, |project, cx| project.worktrees(cx).next().unwrap());
let project_id = active_call_a
.update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
.await
.unwrap();
let project_b = client_b.build_remote_project(project_id, cx_b).await;
assert!(worktree_a.read_with(cx_a, |tree, _| tree.as_local().unwrap().is_shared()));
// Drop client A's connection.
server.forbid_connections();
server.disconnect_client(client_a.peer_id().unwrap());
deterministic.advance_clock(RECEIVE_TIMEOUT);
project_a.read_with(cx_a, |project, _| {
assert!(project.collaborators().is_empty())
});
project_a.read_with(cx_a, |project, _| assert!(!project.is_shared()));
project_b.read_with(cx_b, |project, _| assert!(project.is_read_only()));
worktree_a.read_with(cx_a, |tree, _| {
assert!(!tree.as_local().unwrap().is_shared())
});
// While disconnected, add and remove files from the client A's project.
client_a
.fs
.insert_tree(
"/root/dir1/subdir2",
json!({
"f.txt": "f-contents",
"g.txt": "g-contents",
"h.txt": "h-contents",
"i.txt": "i-contents",
}),
)
.await;
client_a
.fs
.remove_dir(
"/root/dir1/subdir1".as_ref(),
RemoveOptions {
recursive: true,
..Default::default()
},
)
.await
.unwrap();
// Client A reconnects. Their project is re-shared, and client B re-joins it.
server.allow_connections();
deterministic.advance_clock(RECEIVE_TIMEOUT);
project_a.read_with(cx_a, |project, _| assert!(project.is_shared()));
project_b.read_with(cx_b, |project, _| assert!(!project.is_read_only()));
}
#[gpui::test(iterations = 10)]
async fn test_active_call_events(
deterministic: Arc<Deterministic>,