1use super::*;
2use crate::test_both_dbs;
3use language::proto;
4use text::Buffer;
5
6test_both_dbs!(
7 test_channel_buffers,
8 test_channel_buffers_postgres,
9 test_channel_buffers_sqlite
10);
11
12async fn test_channel_buffers(db: &Arc<Database>) {
13 // Prep database test info
14 let a_id = db
15 .create_user(
16 "user_a@example.com",
17 false,
18 NewUserParams {
19 github_login: "user_a".into(),
20 github_user_id: 101,
21 invite_count: 0,
22 },
23 )
24 .await
25 .unwrap()
26 .user_id;
27 let b_id = db
28 .create_user(
29 "user_b@example.com",
30 false,
31 NewUserParams {
32 github_login: "user_b".into(),
33 github_user_id: 102,
34 invite_count: 0,
35 },
36 )
37 .await
38 .unwrap()
39 .user_id;
40 // This user will not be a part of the channel
41 let c_id = db
42 .create_user(
43 "user_b@example.com",
44 false,
45 NewUserParams {
46 github_login: "user_b".into(),
47 github_user_id: 102,
48 invite_count: 0,
49 },
50 )
51 .await
52 .unwrap()
53 .user_id;
54
55 let owner_id = db.create_server("production").await.unwrap().0 as u32;
56
57 let zed_id = db.create_root_channel("zed", "1", a_id).await.unwrap();
58
59 db.invite_channel_member(zed_id, b_id, a_id, false)
60 .await
61 .unwrap();
62
63 db.respond_to_channel_invite(zed_id, b_id, true)
64 .await
65 .unwrap();
66
67 let buffer_response_a = db
68 .join_buffer_for_channel(zed_id, a_id, ConnectionId { owner_id, id: 1 })
69 .await
70 .unwrap();
71 let buffer_id = BufferId::from_proto(buffer_response_a.buffer_id);
72
73 let mut buffer_a = Buffer::new(0, 0, "".to_string());
74 let mut operations = Vec::new();
75 operations.push(buffer_a.edit([(0..0, "hello world")]));
76 operations.push(buffer_a.edit([(5..5, ", cruel")]));
77 operations.push(buffer_a.edit([(0..5, "goodbye")]));
78 operations.push(buffer_a.undo().unwrap().1);
79 assert_eq!(buffer_a.text(), "hello, cruel world");
80
81 let operations = operations
82 .into_iter()
83 .map(|op| proto::serialize_operation(&language::Operation::Buffer(op)))
84 .collect::<Vec<_>>();
85
86 db.update_buffer(buffer_id, &operations).await.unwrap();
87
88 let buffer_response_b = db
89 .join_buffer_for_channel(zed_id, b_id, ConnectionId { owner_id, id: 2 })
90 .await
91 .unwrap();
92
93 let mut buffer_b = Buffer::new(0, 0, buffer_response_b.base_text);
94 buffer_b
95 .apply_ops(buffer_response_b.operations.into_iter().map(|operation| {
96 let operation = proto::deserialize_operation(operation).unwrap();
97 if let language::Operation::Buffer(operation) = operation {
98 operation
99 } else {
100 unreachable!()
101 }
102 }))
103 .unwrap();
104
105 assert_eq!(buffer_b.text(), "hello, cruel world");
106
107 // Ensure that C fails to open the buffer
108 assert!(db
109 .join_buffer_for_channel(zed_id, c_id, ConnectionId { owner_id, id: 3 })
110 .await
111 .is_err());
112
113 //Ensure that both collaborators have shown up
114 assert_eq!(
115 buffer_response_b.collaborators,
116 &[
117 rpc::proto::Collaborator {
118 user_id: a_id.to_proto(),
119 peer_id: Some(rpc::proto::PeerId { id: 1, owner_id }),
120 replica_id: 0,
121 },
122 rpc::proto::Collaborator {
123 user_id: b_id.to_proto(),
124 peer_id: Some(rpc::proto::PeerId { id: 2, owner_id }),
125 replica_id: 1,
126 }
127 ]
128 );
129
130 // Leave buffer
131}