1use crate::{
2 db::{Database, NewUserParams},
3 test_both_dbs,
4};
5use std::sync::Arc;
6use time::OffsetDateTime;
7
8test_both_dbs!(
9 test_channel_message_nonces,
10 test_channel_message_nonces_postgres,
11 test_channel_message_nonces_sqlite
12);
13
14async fn test_channel_message_nonces(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
35 db.join_channel_chat(channel, rpc::ConnectionId { owner_id, id: 0 }, user)
36 .await
37 .unwrap();
38
39 let msg1_id = db
40 .create_channel_message(channel, user, "1", OffsetDateTime::now_utc(), 1)
41 .await
42 .unwrap();
43 let msg2_id = db
44 .create_channel_message(channel, user, "2", OffsetDateTime::now_utc(), 2)
45 .await
46 .unwrap();
47 let msg3_id = db
48 .create_channel_message(channel, user, "3", OffsetDateTime::now_utc(), 1)
49 .await
50 .unwrap();
51 let msg4_id = db
52 .create_channel_message(channel, user, "4", OffsetDateTime::now_utc(), 2)
53 .await
54 .unwrap();
55
56 assert_ne!(msg1_id, msg2_id);
57 assert_eq!(msg1_id, msg3_id);
58 assert_eq!(msg2_id, msg4_id);
59}
60
61test_both_dbs!(
62 test_channel_message_new_notification,
63 test_channel_message_new_notification_postgres,
64 test_channel_message_new_notification_sqlite
65);
66
67async fn test_channel_message_new_notification(db: &Arc<Database>) {
68 let user = db
69 .create_user(
70 "user_a@example.com",
71 false,
72 NewUserParams {
73 github_login: "user_a".into(),
74 github_user_id: 1,
75 invite_count: 0,
76 },
77 )
78 .await
79 .unwrap()
80 .user_id;
81 let observer = db
82 .create_user(
83 "user_b@example.com",
84 false,
85 NewUserParams {
86 github_login: "user_b".into(),
87 github_user_id: 1,
88 invite_count: 0,
89 },
90 )
91 .await
92 .unwrap()
93 .user_id;
94
95 let channel_1 = db
96 .create_channel("channel", None, "room", user)
97 .await
98 .unwrap();
99
100 let channel_2 = db
101 .create_channel("channel-2", None, "room", user)
102 .await
103 .unwrap();
104
105 db.invite_channel_member(channel_1, observer, user, false)
106 .await
107 .unwrap();
108
109 db.respond_to_channel_invite(channel_1, observer, true)
110 .await
111 .unwrap();
112
113 db.invite_channel_member(channel_2, observer, user, false)
114 .await
115 .unwrap();
116
117 db.respond_to_channel_invite(channel_2, observer, true)
118 .await
119 .unwrap();
120
121 let owner_id = db.create_server("test").await.unwrap().0 as u32;
122 let user_connection_id = rpc::ConnectionId { owner_id, id: 0 };
123
124 db.join_channel_chat(channel_1, user_connection_id, user)
125 .await
126 .unwrap();
127
128 let _ = db
129 .create_channel_message(channel_1, user, "1_1", OffsetDateTime::now_utc(), 1)
130 .await
131 .unwrap();
132
133 let (second_message, _, _) = db
134 .create_channel_message(channel_1, user, "1_2", OffsetDateTime::now_utc(), 2)
135 .await
136 .unwrap();
137
138 let (third_message, _, _) = db
139 .create_channel_message(channel_1, user, "1_3", OffsetDateTime::now_utc(), 3)
140 .await
141 .unwrap();
142
143 db.join_channel_chat(channel_2, user_connection_id, user)
144 .await
145 .unwrap();
146
147 let (fourth_message, _, _) = db
148 .create_channel_message(channel_2, user, "2_1", OffsetDateTime::now_utc(), 4)
149 .await
150 .unwrap();
151
152 // Check that observer has new messages
153 let unseen_messages = db
154 .transaction(|tx| async move {
155 db.unseen_channel_messages(observer, &[channel_1, channel_2], &*tx)
156 .await
157 })
158 .await
159 .unwrap();
160
161 assert_eq!(
162 unseen_messages,
163 [
164 rpc::proto::UnseenChannelMessage {
165 channel_id: channel_1.to_proto(),
166 message_id: third_message.to_proto(),
167 },
168 rpc::proto::UnseenChannelMessage {
169 channel_id: channel_2.to_proto(),
170 message_id: fourth_message.to_proto(),
171 },
172 ]
173 );
174
175 // Observe the second message
176 db.observe_channel_message(channel_1, observer, second_message)
177 .await
178 .unwrap();
179
180 // Make sure the observer still has a new message
181 let unseen_messages = db
182 .transaction(|tx| async move {
183 db.unseen_channel_messages(observer, &[channel_1, channel_2], &*tx)
184 .await
185 })
186 .await
187 .unwrap();
188 assert_eq!(
189 unseen_messages,
190 [
191 rpc::proto::UnseenChannelMessage {
192 channel_id: channel_1.to_proto(),
193 message_id: third_message.to_proto(),
194 },
195 rpc::proto::UnseenChannelMessage {
196 channel_id: channel_2.to_proto(),
197 message_id: fourth_message.to_proto(),
198 },
199 ]
200 );
201
202 // Observe the third message,
203 db.observe_channel_message(channel_1, observer, third_message)
204 .await
205 .unwrap();
206
207 // Make sure the observer does not have a new method
208 let unseen_messages = db
209 .transaction(|tx| async move {
210 db.unseen_channel_messages(observer, &[channel_1, channel_2], &*tx)
211 .await
212 })
213 .await
214 .unwrap();
215
216 assert_eq!(
217 unseen_messages,
218 [rpc::proto::UnseenChannelMessage {
219 channel_id: channel_2.to_proto(),
220 message_id: fourth_message.to_proto(),
221 }]
222 );
223
224 // Observe the second message again, should not regress our observed state
225 db.observe_channel_message(channel_1, observer, second_message)
226 .await
227 .unwrap();
228
229 // Make sure the observer does not have a new message
230 let unseen_messages = db
231 .transaction(|tx| async move {
232 db.unseen_channel_messages(observer, &[channel_1, channel_2], &*tx)
233 .await
234 })
235 .await
236 .unwrap();
237 assert_eq!(
238 unseen_messages,
239 [rpc::proto::UnseenChannelMessage {
240 channel_id: channel_2.to_proto(),
241 message_id: fourth_message.to_proto(),
242 }]
243 );
244}