1use crate::{
2 db::{
3 tests::{channel_tree, new_test_connection, new_test_user},
4 Channel, ChannelId, ChannelRole, Database, NewUserParams, RoomId, UserId,
5 },
6 test_both_dbs,
7};
8use rpc::{
9 proto::{self},
10 ConnectionId,
11};
12use std::sync::Arc;
13
14test_both_dbs!(test_channels, test_channels_postgres, test_channels_sqlite);
15
16async fn test_channels(db: &Arc<Database>) {
17 let a_id = new_test_user(db, "user1@example.com").await;
18 let b_id = new_test_user(db, "user2@example.com").await;
19
20 let zed_id = db.create_root_channel("zed", a_id).await.unwrap();
21
22 // Make sure that people cannot read channels they haven't been invited to
23 assert!(db.get_channel(zed_id, b_id).await.is_err());
24
25 db.invite_channel_member(zed_id, b_id, a_id, ChannelRole::Member)
26 .await
27 .unwrap();
28
29 db.respond_to_channel_invite(zed_id, b_id, true)
30 .await
31 .unwrap();
32
33 let crdb_id = db.create_sub_channel("crdb", zed_id, a_id).await.unwrap();
34 let livestreaming_id = db
35 .create_sub_channel("livestreaming", zed_id, a_id)
36 .await
37 .unwrap();
38 let replace_id = db
39 .create_sub_channel("replace", zed_id, a_id)
40 .await
41 .unwrap();
42
43 let (members, _) = db
44 .get_channel_participant_details(replace_id, "", 10, a_id)
45 .await
46 .unwrap();
47 let ids = members
48 .into_iter()
49 .map(|m| UserId::from_proto(m.user_id))
50 .collect::<Vec<_>>();
51 assert_eq!(ids, &[a_id, b_id]);
52
53 let rust_id = db.create_root_channel("rust", a_id).await.unwrap();
54 let cargo_id = db.create_sub_channel("cargo", rust_id, a_id).await.unwrap();
55
56 let cargo_ra_id = db
57 .create_sub_channel("cargo-ra", cargo_id, a_id)
58 .await
59 .unwrap();
60
61 let result = db.get_channels_for_user(a_id).await.unwrap();
62 assert_eq!(
63 result.channels,
64 channel_tree(&[
65 (zed_id, &[], "zed"),
66 (crdb_id, &[zed_id], "crdb"),
67 (livestreaming_id, &[zed_id], "livestreaming",),
68 (replace_id, &[zed_id], "replace"),
69 (rust_id, &[], "rust"),
70 (cargo_id, &[rust_id], "cargo"),
71 (cargo_ra_id, &[rust_id, cargo_id], "cargo-ra",)
72 ],)
73 );
74
75 let result = db.get_channels_for_user(b_id).await.unwrap();
76 assert_eq!(
77 result.channels,
78 channel_tree(&[
79 (zed_id, &[], "zed"),
80 (crdb_id, &[zed_id], "crdb"),
81 (livestreaming_id, &[zed_id], "livestreaming",),
82 (replace_id, &[zed_id], "replace")
83 ],)
84 );
85
86 // Update member permissions
87 let set_subchannel_admin = db
88 .set_channel_member_role(crdb_id, a_id, b_id, ChannelRole::Admin)
89 .await;
90 assert!(set_subchannel_admin.is_err());
91 let set_channel_admin = db
92 .set_channel_member_role(zed_id, a_id, b_id, ChannelRole::Admin)
93 .await;
94 assert!(set_channel_admin.is_ok());
95
96 let result = db.get_channels_for_user(b_id).await.unwrap();
97 assert_eq!(
98 result.channels,
99 channel_tree(&[
100 (zed_id, &[], "zed"),
101 (crdb_id, &[zed_id], "crdb"),
102 (livestreaming_id, &[zed_id], "livestreaming",),
103 (replace_id, &[zed_id], "replace")
104 ],)
105 );
106
107 // Remove a single channel
108 db.delete_channel(crdb_id, a_id).await.unwrap();
109 assert!(db.get_channel(crdb_id, a_id).await.is_err());
110
111 // Remove a channel tree
112 let (_, mut channel_ids) = db.delete_channel(rust_id, a_id).await.unwrap();
113 channel_ids.sort();
114 assert_eq!(channel_ids, &[rust_id, cargo_id, cargo_ra_id]);
115
116 assert!(db.get_channel(rust_id, a_id).await.is_err());
117 assert!(db.get_channel(cargo_id, a_id).await.is_err());
118 assert!(db.get_channel(cargo_ra_id, a_id).await.is_err());
119}
120
121test_both_dbs!(
122 test_joining_channels,
123 test_joining_channels_postgres,
124 test_joining_channels_sqlite
125);
126
127async fn test_joining_channels(db: &Arc<Database>) {
128 let owner_id = db.create_server("test").await.unwrap().0 as u32;
129
130 let user_1 = new_test_user(db, "user1@example.com").await;
131 let user_2 = new_test_user(db, "user2@example.com").await;
132
133 let channel_1 = db.create_root_channel("channel_1", user_1).await.unwrap();
134
135 // can join a room with membership to its channel
136 let (joined_room, _, _) = db
137 .join_channel(channel_1, user_1, ConnectionId { owner_id, id: 1 })
138 .await
139 .unwrap();
140 assert_eq!(joined_room.room.participants.len(), 1);
141
142 let room_id = RoomId::from_proto(joined_room.room.id);
143 drop(joined_room);
144 // cannot join a room without membership to its channel
145 assert!(db
146 .join_room(room_id, user_2, ConnectionId { owner_id, id: 1 },)
147 .await
148 .is_err());
149}
150
151test_both_dbs!(
152 test_channel_invites,
153 test_channel_invites_postgres,
154 test_channel_invites_sqlite
155);
156
157async fn test_channel_invites(db: &Arc<Database>) {
158 db.create_server("test").await.unwrap();
159
160 let user_1 = new_test_user(db, "user1@example.com").await;
161 let user_2 = new_test_user(db, "user2@example.com").await;
162 let user_3 = new_test_user(db, "user3@example.com").await;
163
164 let channel_1_1 = db.create_root_channel("channel_1", user_1).await.unwrap();
165
166 let channel_1_2 = db.create_root_channel("channel_2", user_1).await.unwrap();
167
168 db.invite_channel_member(channel_1_1, user_2, user_1, ChannelRole::Member)
169 .await
170 .unwrap();
171 db.invite_channel_member(channel_1_2, user_2, user_1, ChannelRole::Member)
172 .await
173 .unwrap();
174 db.invite_channel_member(channel_1_1, user_3, user_1, ChannelRole::Admin)
175 .await
176 .unwrap();
177
178 let user_2_invites = db
179 .get_channels_for_user(user_2)
180 .await
181 .unwrap()
182 .invited_channels
183 .into_iter()
184 .map(|channel| channel.id)
185 .collect::<Vec<_>>();
186 assert_eq!(user_2_invites, &[channel_1_1, channel_1_2]);
187
188 let user_3_invites = db
189 .get_channels_for_user(user_3)
190 .await
191 .unwrap()
192 .invited_channels
193 .into_iter()
194 .map(|channel| channel.id)
195 .collect::<Vec<_>>();
196 assert_eq!(user_3_invites, &[channel_1_1]);
197
198 let (mut members, _) = db
199 .get_channel_participant_details(channel_1_1, "", 100, user_1)
200 .await
201 .unwrap();
202
203 members.sort_by_key(|member| member.user_id);
204 assert_eq!(
205 members,
206 &[
207 proto::ChannelMember {
208 user_id: user_1.to_proto(),
209 kind: proto::channel_member::Kind::Member.into(),
210 role: proto::ChannelRole::Admin.into(),
211 },
212 proto::ChannelMember {
213 user_id: user_2.to_proto(),
214 kind: proto::channel_member::Kind::Invitee.into(),
215 role: proto::ChannelRole::Member.into(),
216 },
217 proto::ChannelMember {
218 user_id: user_3.to_proto(),
219 kind: proto::channel_member::Kind::Invitee.into(),
220 role: proto::ChannelRole::Admin.into(),
221 },
222 ]
223 );
224
225 db.respond_to_channel_invite(channel_1_1, user_2, true)
226 .await
227 .unwrap();
228
229 let channel_1_3 = db
230 .create_sub_channel("channel_3", channel_1_1, user_1)
231 .await
232 .unwrap();
233
234 let (members, _) = db
235 .get_channel_participant_details(channel_1_3, "", 100, user_1)
236 .await
237 .unwrap();
238 assert_eq!(
239 members,
240 &[
241 proto::ChannelMember {
242 user_id: user_1.to_proto(),
243 kind: proto::channel_member::Kind::Member.into(),
244 role: proto::ChannelRole::Admin.into(),
245 },
246 proto::ChannelMember {
247 user_id: user_3.to_proto(),
248 kind: proto::channel_member::Kind::Invitee.into(),
249 role: proto::ChannelRole::Admin.into(),
250 },
251 proto::ChannelMember {
252 user_id: user_2.to_proto(),
253 kind: proto::channel_member::Kind::Member.into(),
254 role: proto::ChannelRole::Member.into(),
255 },
256 ]
257 );
258}
259
260test_both_dbs!(
261 test_channel_renames,
262 test_channel_renames_postgres,
263 test_channel_renames_sqlite
264);
265
266async fn test_channel_renames(db: &Arc<Database>) {
267 db.create_server("test").await.unwrap();
268
269 let user_1 = db
270 .create_user(
271 "user1@example.com",
272 false,
273 NewUserParams {
274 github_login: "user1".into(),
275 github_user_id: 5,
276 },
277 )
278 .await
279 .unwrap()
280 .user_id;
281
282 let user_2 = db
283 .create_user(
284 "user2@example.com",
285 false,
286 NewUserParams {
287 github_login: "user2".into(),
288 github_user_id: 6,
289 },
290 )
291 .await
292 .unwrap()
293 .user_id;
294
295 let zed_id = db.create_root_channel("zed", user_1).await.unwrap();
296
297 db.rename_channel(zed_id, user_1, "#zed-archive")
298 .await
299 .unwrap();
300
301 let channel = db.get_channel(zed_id, user_1).await.unwrap();
302 assert_eq!(channel.name, "zed-archive");
303
304 let non_permissioned_rename = db.rename_channel(zed_id, user_2, "hacked-lol").await;
305 assert!(non_permissioned_rename.is_err());
306
307 let bad_name_rename = db.rename_channel(zed_id, user_1, "#").await;
308 assert!(bad_name_rename.is_err())
309}
310
311test_both_dbs!(
312 test_db_channel_moving,
313 test_channels_moving_postgres,
314 test_channels_moving_sqlite
315);
316
317async fn test_db_channel_moving(db: &Arc<Database>) {
318 let a_id = db
319 .create_user(
320 "user1@example.com",
321 false,
322 NewUserParams {
323 github_login: "user1".into(),
324 github_user_id: 5,
325 },
326 )
327 .await
328 .unwrap()
329 .user_id;
330
331 let zed_id = db.create_root_channel("zed", a_id).await.unwrap();
332
333 let crdb_id = db.create_sub_channel("crdb", zed_id, a_id).await.unwrap();
334
335 let gpui2_id = db.create_sub_channel("gpui2", zed_id, a_id).await.unwrap();
336
337 let livestreaming_id = db
338 .create_sub_channel("livestreaming", crdb_id, a_id)
339 .await
340 .unwrap();
341
342 let livestreaming_dag_id = db
343 .create_sub_channel("livestreaming_dag", livestreaming_id, a_id)
344 .await
345 .unwrap();
346
347 // ========================================================================
348 // sanity check
349 // Initial DAG:
350 // /- gpui2
351 // zed -- crdb - livestreaming - livestreaming_dag
352 let result = db.get_channels_for_user(a_id).await.unwrap();
353 assert_channel_tree(
354 result.channels,
355 &[
356 (zed_id, &[]),
357 (crdb_id, &[zed_id]),
358 (livestreaming_id, &[zed_id, crdb_id]),
359 (livestreaming_dag_id, &[zed_id, crdb_id, livestreaming_id]),
360 (gpui2_id, &[zed_id]),
361 ],
362 );
363}
364
365test_both_dbs!(
366 test_db_channel_moving_bugs,
367 test_db_channel_moving_bugs_postgres,
368 test_db_channel_moving_bugs_sqlite
369);
370
371async fn test_db_channel_moving_bugs(db: &Arc<Database>) {
372 let user_id = db
373 .create_user(
374 "user1@example.com",
375 false,
376 NewUserParams {
377 github_login: "user1".into(),
378 github_user_id: 5,
379 },
380 )
381 .await
382 .unwrap()
383 .user_id;
384
385 let zed_id = db.create_root_channel("zed", user_id).await.unwrap();
386
387 let projects_id = db
388 .create_sub_channel("projects", zed_id, user_id)
389 .await
390 .unwrap();
391
392 let livestreaming_id = db
393 .create_sub_channel("livestreaming", projects_id, user_id)
394 .await
395 .unwrap();
396
397 let result = db.get_channels_for_user(user_id).await.unwrap();
398 assert_channel_tree(
399 result.channels,
400 &[
401 (zed_id, &[]),
402 (projects_id, &[zed_id]),
403 (livestreaming_id, &[zed_id, projects_id]),
404 ],
405 );
406
407 // Can't move a channel into its ancestor
408 db.move_channel(projects_id, livestreaming_id, user_id)
409 .await
410 .unwrap_err();
411 let result = db.get_channels_for_user(user_id).await.unwrap();
412 assert_channel_tree(
413 result.channels,
414 &[
415 (zed_id, &[]),
416 (projects_id, &[zed_id]),
417 (livestreaming_id, &[zed_id, projects_id]),
418 ],
419 );
420}
421
422test_both_dbs!(
423 test_user_is_channel_participant,
424 test_user_is_channel_participant_postgres,
425 test_user_is_channel_participant_sqlite
426);
427
428async fn test_user_is_channel_participant(db: &Arc<Database>) {
429 let admin = new_test_user(db, "admin@example.com").await;
430 let member = new_test_user(db, "member@example.com").await;
431 let guest = new_test_user(db, "guest@example.com").await;
432
433 let zed_channel = db.create_root_channel("zed", admin).await.unwrap();
434 let internal_channel_id = db
435 .create_sub_channel("active", zed_channel, admin)
436 .await
437 .unwrap();
438 let public_channel_id = db
439 .create_sub_channel("vim", zed_channel, admin)
440 .await
441 .unwrap();
442
443 db.set_channel_visibility(zed_channel, crate::db::ChannelVisibility::Public, admin)
444 .await
445 .unwrap();
446 db.set_channel_visibility(
447 public_channel_id,
448 crate::db::ChannelVisibility::Public,
449 admin,
450 )
451 .await
452 .unwrap();
453 db.invite_channel_member(zed_channel, member, admin, ChannelRole::Member)
454 .await
455 .unwrap();
456 db.invite_channel_member(zed_channel, guest, admin, ChannelRole::Guest)
457 .await
458 .unwrap();
459
460 db.respond_to_channel_invite(zed_channel, member, true)
461 .await
462 .unwrap();
463
464 db.transaction(|tx| async move {
465 db.check_user_is_channel_participant(
466 &db.get_channel_internal(public_channel_id, &tx).await?,
467 admin,
468 &tx,
469 )
470 .await
471 })
472 .await
473 .unwrap();
474 db.transaction(|tx| async move {
475 db.check_user_is_channel_participant(
476 &db.get_channel_internal(public_channel_id, &tx).await?,
477 member,
478 &tx,
479 )
480 .await
481 })
482 .await
483 .unwrap();
484
485 let (mut members, _) = db
486 .get_channel_participant_details(public_channel_id, "", 100, admin)
487 .await
488 .unwrap();
489
490 members.sort_by_key(|member| member.user_id);
491
492 assert_eq!(
493 members,
494 &[
495 proto::ChannelMember {
496 user_id: admin.to_proto(),
497 kind: proto::channel_member::Kind::Member.into(),
498 role: proto::ChannelRole::Admin.into(),
499 },
500 proto::ChannelMember {
501 user_id: member.to_proto(),
502 kind: proto::channel_member::Kind::Member.into(),
503 role: proto::ChannelRole::Member.into(),
504 },
505 proto::ChannelMember {
506 user_id: guest.to_proto(),
507 kind: proto::channel_member::Kind::Invitee.into(),
508 role: proto::ChannelRole::Guest.into(),
509 },
510 ]
511 );
512
513 db.respond_to_channel_invite(zed_channel, guest, true)
514 .await
515 .unwrap();
516
517 db.transaction(|tx| async move {
518 db.check_user_is_channel_participant(
519 &db.get_channel_internal(public_channel_id, &tx).await?,
520 guest,
521 &tx,
522 )
523 .await
524 })
525 .await
526 .unwrap();
527
528 let channels = db.get_channels_for_user(guest).await.unwrap().channels;
529 assert_channel_tree(
530 channels,
531 &[(zed_channel, &[]), (public_channel_id, &[zed_channel])],
532 );
533 let channels = db.get_channels_for_user(member).await.unwrap().channels;
534 assert_channel_tree(
535 channels,
536 &[
537 (zed_channel, &[]),
538 (internal_channel_id, &[zed_channel]),
539 (public_channel_id, &[zed_channel]),
540 ],
541 );
542
543 db.set_channel_member_role(zed_channel, admin, guest, ChannelRole::Banned)
544 .await
545 .unwrap();
546 assert!(db
547 .transaction(|tx| async move {
548 db.check_user_is_channel_participant(
549 &db.get_channel_internal(public_channel_id, &tx)
550 .await
551 .unwrap(),
552 guest,
553 &tx,
554 )
555 .await
556 })
557 .await
558 .is_err());
559
560 let (mut members, _) = db
561 .get_channel_participant_details(public_channel_id, "", 100, admin)
562 .await
563 .unwrap();
564
565 members.sort_by_key(|member| member.user_id);
566
567 assert_eq!(
568 members,
569 &[
570 proto::ChannelMember {
571 user_id: admin.to_proto(),
572 kind: proto::channel_member::Kind::Member.into(),
573 role: proto::ChannelRole::Admin.into(),
574 },
575 proto::ChannelMember {
576 user_id: member.to_proto(),
577 kind: proto::channel_member::Kind::Member.into(),
578 role: proto::ChannelRole::Member.into(),
579 },
580 proto::ChannelMember {
581 user_id: guest.to_proto(),
582 kind: proto::channel_member::Kind::Member.into(),
583 role: proto::ChannelRole::Banned.into(),
584 },
585 ]
586 );
587
588 db.remove_channel_member(zed_channel, guest, admin)
589 .await
590 .unwrap();
591
592 db.invite_channel_member(zed_channel, guest, admin, ChannelRole::Guest)
593 .await
594 .unwrap();
595
596 // currently people invited to parent channels are not shown here
597 let (mut members, _) = db
598 .get_channel_participant_details(public_channel_id, "", 100, admin)
599 .await
600 .unwrap();
601
602 members.sort_by_key(|member| member.user_id);
603
604 assert_eq!(
605 members,
606 &[
607 proto::ChannelMember {
608 user_id: admin.to_proto(),
609 kind: proto::channel_member::Kind::Member.into(),
610 role: proto::ChannelRole::Admin.into(),
611 },
612 proto::ChannelMember {
613 user_id: member.to_proto(),
614 kind: proto::channel_member::Kind::Member.into(),
615 role: proto::ChannelRole::Member.into(),
616 },
617 proto::ChannelMember {
618 user_id: guest.to_proto(),
619 kind: proto::channel_member::Kind::Invitee.into(),
620 role: proto::ChannelRole::Guest.into(),
621 },
622 ]
623 );
624
625 db.respond_to_channel_invite(zed_channel, guest, true)
626 .await
627 .unwrap();
628
629 db.transaction(|tx| async move {
630 db.check_user_is_channel_participant(
631 &db.get_channel_internal(zed_channel, &tx).await.unwrap(),
632 guest,
633 &tx,
634 )
635 .await
636 })
637 .await
638 .unwrap();
639 assert!(db
640 .transaction(|tx| async move {
641 db.check_user_is_channel_participant(
642 &db.get_channel_internal(internal_channel_id, &tx)
643 .await
644 .unwrap(),
645 guest,
646 &tx,
647 )
648 .await
649 })
650 .await
651 .is_err(),);
652
653 db.transaction(|tx| async move {
654 db.check_user_is_channel_participant(
655 &db.get_channel_internal(public_channel_id, &tx)
656 .await
657 .unwrap(),
658 guest,
659 &tx,
660 )
661 .await
662 })
663 .await
664 .unwrap();
665
666 let (mut members, _) = db
667 .get_channel_participant_details(public_channel_id, "", 100, admin)
668 .await
669 .unwrap();
670
671 members.sort_by_key(|member| member.user_id);
672
673 assert_eq!(
674 members,
675 &[
676 proto::ChannelMember {
677 user_id: admin.to_proto(),
678 kind: proto::channel_member::Kind::Member.into(),
679 role: proto::ChannelRole::Admin.into(),
680 },
681 proto::ChannelMember {
682 user_id: member.to_proto(),
683 kind: proto::channel_member::Kind::Member.into(),
684 role: proto::ChannelRole::Member.into(),
685 },
686 proto::ChannelMember {
687 user_id: guest.to_proto(),
688 kind: proto::channel_member::Kind::Member.into(),
689 role: proto::ChannelRole::Guest.into(),
690 },
691 ]
692 );
693
694 let channels = db.get_channels_for_user(guest).await.unwrap().channels;
695 assert_channel_tree(
696 channels,
697 &[(zed_channel, &[]), (public_channel_id, &[zed_channel])],
698 )
699}
700
701test_both_dbs!(
702 test_guest_access,
703 test_guest_access_postgres,
704 test_guest_access_sqlite
705);
706
707async fn test_guest_access(db: &Arc<Database>) {
708 let server = db.create_server("test").await.unwrap();
709
710 let admin = new_test_user(db, "admin@example.com").await;
711 let guest = new_test_user(db, "guest@example.com").await;
712 let guest_connection = new_test_connection(server);
713
714 let zed_channel = db.create_root_channel("zed", admin).await.unwrap();
715 db.set_channel_visibility(zed_channel, crate::db::ChannelVisibility::Public, admin)
716 .await
717 .unwrap();
718
719 assert!(db
720 .join_channel_chat(zed_channel, guest_connection, guest)
721 .await
722 .is_err());
723
724 db.join_channel(zed_channel, guest, guest_connection)
725 .await
726 .unwrap();
727
728 assert!(db
729 .join_channel_chat(zed_channel, guest_connection, guest)
730 .await
731 .is_ok())
732}
733
734#[track_caller]
735fn assert_channel_tree(actual: Vec<Channel>, expected: &[(ChannelId, &[ChannelId])]) {
736 let actual = actual
737 .iter()
738 .map(|channel| (channel.id, channel.parent_path.as_slice()))
739 .collect::<Vec<_>>();
740 pretty_assertions::assert_eq!(
741 actual,
742 expected.to_vec(),
743 "wrong channel ids and parent paths"
744 );
745}