1use crate::{
2 db::{Database, MessageId, NewUserParams},
3 test_both_dbs,
4};
5use std::sync::Arc;
6use time::OffsetDateTime;
7
8test_both_dbs!(
9 test_channel_message_retrieval,
10 test_channel_message_retrieval_postgres,
11 test_channel_message_retrieval_sqlite
12);
13
14async fn test_channel_message_retrieval(db: &Arc<Database>) {
15 let user = db
16 .create_user(
17 "user@example.com",
18 false,
19 NewUserParams {
20 github_login: "user".into(),
21 github_user_id: 1,
22 invite_count: 0,
23 },
24 )
25 .await
26 .unwrap()
27 .user_id;
28 let channel = db
29 .create_channel("channel", None, "room", user)
30 .await
31 .unwrap();
32
33 let owner_id = db.create_server("test").await.unwrap().0 as u32;
34 db.join_channel_chat(channel, rpc::ConnectionId { owner_id, id: 0 }, user)
35 .await
36 .unwrap();
37
38 let mut all_messages = Vec::new();
39 for i in 0..10 {
40 all_messages.push(
41 db.create_channel_message(channel, user, &i.to_string(), OffsetDateTime::now_utc(), i)
42 .await
43 .unwrap()
44 .0
45 .to_proto(),
46 );
47 }
48
49 let messages = db
50 .get_channel_messages(channel, user, 3, None)
51 .await
52 .unwrap()
53 .into_iter()
54 .map(|message| message.id)
55 .collect::<Vec<_>>();
56 assert_eq!(messages, &all_messages[7..10]);
57
58 let messages = db
59 .get_channel_messages(
60 channel,
61 user,
62 4,
63 Some(MessageId::from_proto(all_messages[6])),
64 )
65 .await
66 .unwrap()
67 .into_iter()
68 .map(|message| message.id)
69 .collect::<Vec<_>>();
70 assert_eq!(messages, &all_messages[2..6]);
71}
72
73test_both_dbs!(
74 test_channel_message_nonces,
75 test_channel_message_nonces_postgres,
76 test_channel_message_nonces_sqlite
77);
78
79async fn test_channel_message_nonces(db: &Arc<Database>) {
80 let user = db
81 .create_user(
82 "user@example.com",
83 false,
84 NewUserParams {
85 github_login: "user".into(),
86 github_user_id: 1,
87 invite_count: 0,
88 },
89 )
90 .await
91 .unwrap()
92 .user_id;
93 let channel = db
94 .create_channel("channel", None, "room", user)
95 .await
96 .unwrap();
97
98 let owner_id = db.create_server("test").await.unwrap().0 as u32;
99
100 db.join_channel_chat(channel, rpc::ConnectionId { owner_id, id: 0 }, user)
101 .await
102 .unwrap();
103
104 let msg1_id = db
105 .create_channel_message(channel, user, "1", OffsetDateTime::now_utc(), 1)
106 .await
107 .unwrap();
108 let msg2_id = db
109 .create_channel_message(channel, user, "2", OffsetDateTime::now_utc(), 2)
110 .await
111 .unwrap();
112 let msg3_id = db
113 .create_channel_message(channel, user, "3", OffsetDateTime::now_utc(), 1)
114 .await
115 .unwrap();
116 let msg4_id = db
117 .create_channel_message(channel, user, "4", OffsetDateTime::now_utc(), 2)
118 .await
119 .unwrap();
120
121 assert_ne!(msg1_id, msg2_id);
122 assert_eq!(msg1_id, msg3_id);
123 assert_eq!(msg2_id, msg4_id);
124}
125
126test_both_dbs!(
127 test_channel_message_new_notification,
128 test_channel_message_new_notification_postgres,
129 test_channel_message_new_notification_sqlite
130);
131
132async fn test_channel_message_new_notification(db: &Arc<Database>) {
133 let user = db
134 .create_user(
135 "user_a@example.com",
136 false,
137 NewUserParams {
138 github_login: "user_a".into(),
139 github_user_id: 1,
140 invite_count: 0,
141 },
142 )
143 .await
144 .unwrap()
145 .user_id;
146 let observer = db
147 .create_user(
148 "user_b@example.com",
149 false,
150 NewUserParams {
151 github_login: "user_b".into(),
152 github_user_id: 1,
153 invite_count: 0,
154 },
155 )
156 .await
157 .unwrap()
158 .user_id;
159
160 let channel_1 = db
161 .create_channel("channel", None, "room", user)
162 .await
163 .unwrap();
164
165 let channel_2 = db
166 .create_channel("channel-2", None, "room", user)
167 .await
168 .unwrap();
169
170 db.invite_channel_member(channel_1, observer, user, false)
171 .await
172 .unwrap();
173
174 db.respond_to_channel_invite(channel_1, observer, true)
175 .await
176 .unwrap();
177
178 db.invite_channel_member(channel_2, observer, user, false)
179 .await
180 .unwrap();
181
182 db.respond_to_channel_invite(channel_2, observer, true)
183 .await
184 .unwrap();
185
186 let owner_id = db.create_server("test").await.unwrap().0 as u32;
187 let user_connection_id = rpc::ConnectionId { owner_id, id: 0 };
188
189 db.join_channel_chat(channel_1, user_connection_id, user)
190 .await
191 .unwrap();
192
193 let _ = db
194 .create_channel_message(channel_1, user, "1_1", OffsetDateTime::now_utc(), 1)
195 .await
196 .unwrap();
197
198 let (second_message, _, _) = db
199 .create_channel_message(channel_1, user, "1_2", OffsetDateTime::now_utc(), 2)
200 .await
201 .unwrap();
202
203 let (third_message, _, _) = db
204 .create_channel_message(channel_1, user, "1_3", OffsetDateTime::now_utc(), 3)
205 .await
206 .unwrap();
207
208 db.join_channel_chat(channel_2, user_connection_id, user)
209 .await
210 .unwrap();
211
212 let (fourth_message, _, _) = db
213 .create_channel_message(channel_2, user, "2_1", OffsetDateTime::now_utc(), 4)
214 .await
215 .unwrap();
216
217 // Check that observer has new messages
218 let unseen_messages = db
219 .transaction(|tx| async move {
220 db.unseen_channel_messages(observer, &[channel_1, channel_2], &*tx)
221 .await
222 })
223 .await
224 .unwrap();
225
226 assert_eq!(
227 unseen_messages,
228 [
229 rpc::proto::UnseenChannelMessage {
230 channel_id: channel_1.to_proto(),
231 message_id: third_message.to_proto(),
232 },
233 rpc::proto::UnseenChannelMessage {
234 channel_id: channel_2.to_proto(),
235 message_id: fourth_message.to_proto(),
236 },
237 ]
238 );
239
240 // Observe the second message
241 db.observe_channel_message(channel_1, observer, second_message)
242 .await
243 .unwrap();
244
245 // Make sure the observer still has a new message
246 let unseen_messages = db
247 .transaction(|tx| async move {
248 db.unseen_channel_messages(observer, &[channel_1, channel_2], &*tx)
249 .await
250 })
251 .await
252 .unwrap();
253 assert_eq!(
254 unseen_messages,
255 [
256 rpc::proto::UnseenChannelMessage {
257 channel_id: channel_1.to_proto(),
258 message_id: third_message.to_proto(),
259 },
260 rpc::proto::UnseenChannelMessage {
261 channel_id: channel_2.to_proto(),
262 message_id: fourth_message.to_proto(),
263 },
264 ]
265 );
266
267 // Observe the third message,
268 db.observe_channel_message(channel_1, observer, third_message)
269 .await
270 .unwrap();
271
272 // Make sure the observer does not have a new method
273 let unseen_messages = db
274 .transaction(|tx| async move {
275 db.unseen_channel_messages(observer, &[channel_1, channel_2], &*tx)
276 .await
277 })
278 .await
279 .unwrap();
280
281 assert_eq!(
282 unseen_messages,
283 [rpc::proto::UnseenChannelMessage {
284 channel_id: channel_2.to_proto(),
285 message_id: fourth_message.to_proto(),
286 }]
287 );
288
289 // Observe the second message again, should not regress our observed state
290 db.observe_channel_message(channel_1, observer, second_message)
291 .await
292 .unwrap();
293
294 // Make sure the observer does not have a new message
295 let unseen_messages = db
296 .transaction(|tx| async move {
297 db.unseen_channel_messages(observer, &[channel_1, channel_2], &*tx)
298 .await
299 })
300 .await
301 .unwrap();
302 assert_eq!(
303 unseen_messages,
304 [rpc::proto::UnseenChannelMessage {
305 channel_id: channel_2.to_proto(),
306 message_id: fourth_message.to_proto(),
307 }]
308 );
309}