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