310 lines
8.2 KiB
Rust
310 lines
8.2 KiB
Rust
use crate::{
|
|
db::{Database, MessageId, NewUserParams},
|
|
test_both_dbs,
|
|
};
|
|
use std::sync::Arc;
|
|
use time::OffsetDateTime;
|
|
|
|
test_both_dbs!(
|
|
test_channel_message_retrieval,
|
|
test_channel_message_retrieval_postgres,
|
|
test_channel_message_retrieval_sqlite
|
|
);
|
|
|
|
async fn test_channel_message_retrieval(db: &Arc<Database>) {
|
|
let user = db
|
|
.create_user(
|
|
"user@example.com",
|
|
false,
|
|
NewUserParams {
|
|
github_login: "user".into(),
|
|
github_user_id: 1,
|
|
invite_count: 0,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap()
|
|
.user_id;
|
|
let channel = db
|
|
.create_channel("channel", None, "room", user)
|
|
.await
|
|
.unwrap();
|
|
|
|
let owner_id = db.create_server("test").await.unwrap().0 as u32;
|
|
db.join_channel_chat(channel, rpc::ConnectionId { owner_id, id: 0 }, user)
|
|
.await
|
|
.unwrap();
|
|
|
|
let mut all_messages = Vec::new();
|
|
for i in 0..10 {
|
|
all_messages.push(
|
|
db.create_channel_message(channel, user, &i.to_string(), OffsetDateTime::now_utc(), i)
|
|
.await
|
|
.unwrap()
|
|
.0
|
|
.to_proto(),
|
|
);
|
|
}
|
|
|
|
let messages = db
|
|
.get_channel_messages(channel, user, 3, None)
|
|
.await
|
|
.unwrap()
|
|
.into_iter()
|
|
.map(|message| message.id)
|
|
.collect::<Vec<_>>();
|
|
assert_eq!(messages, &all_messages[7..10]);
|
|
|
|
let messages = db
|
|
.get_channel_messages(
|
|
channel,
|
|
user,
|
|
4,
|
|
Some(MessageId::from_proto(all_messages[6])),
|
|
)
|
|
.await
|
|
.unwrap()
|
|
.into_iter()
|
|
.map(|message| message.id)
|
|
.collect::<Vec<_>>();
|
|
assert_eq!(messages, &all_messages[2..6]);
|
|
}
|
|
|
|
test_both_dbs!(
|
|
test_channel_message_nonces,
|
|
test_channel_message_nonces_postgres,
|
|
test_channel_message_nonces_sqlite
|
|
);
|
|
|
|
async fn test_channel_message_nonces(db: &Arc<Database>) {
|
|
let user = db
|
|
.create_user(
|
|
"user@example.com",
|
|
false,
|
|
NewUserParams {
|
|
github_login: "user".into(),
|
|
github_user_id: 1,
|
|
invite_count: 0,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap()
|
|
.user_id;
|
|
let channel = db
|
|
.create_channel("channel", None, "room", user)
|
|
.await
|
|
.unwrap();
|
|
|
|
let owner_id = db.create_server("test").await.unwrap().0 as u32;
|
|
|
|
db.join_channel_chat(channel, rpc::ConnectionId { owner_id, id: 0 }, user)
|
|
.await
|
|
.unwrap();
|
|
|
|
let msg1_id = db
|
|
.create_channel_message(channel, user, "1", OffsetDateTime::now_utc(), 1)
|
|
.await
|
|
.unwrap();
|
|
let msg2_id = db
|
|
.create_channel_message(channel, user, "2", OffsetDateTime::now_utc(), 2)
|
|
.await
|
|
.unwrap();
|
|
let msg3_id = db
|
|
.create_channel_message(channel, user, "3", OffsetDateTime::now_utc(), 1)
|
|
.await
|
|
.unwrap();
|
|
let msg4_id = db
|
|
.create_channel_message(channel, user, "4", OffsetDateTime::now_utc(), 2)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_ne!(msg1_id, msg2_id);
|
|
assert_eq!(msg1_id, msg3_id);
|
|
assert_eq!(msg2_id, msg4_id);
|
|
}
|
|
|
|
test_both_dbs!(
|
|
test_channel_message_new_notification,
|
|
test_channel_message_new_notification_postgres,
|
|
test_channel_message_new_notification_sqlite
|
|
);
|
|
|
|
async fn test_channel_message_new_notification(db: &Arc<Database>) {
|
|
let user = db
|
|
.create_user(
|
|
"user_a@example.com",
|
|
false,
|
|
NewUserParams {
|
|
github_login: "user_a".into(),
|
|
github_user_id: 1,
|
|
invite_count: 0,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap()
|
|
.user_id;
|
|
let observer = db
|
|
.create_user(
|
|
"user_b@example.com",
|
|
false,
|
|
NewUserParams {
|
|
github_login: "user_b".into(),
|
|
github_user_id: 1,
|
|
invite_count: 0,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap()
|
|
.user_id;
|
|
|
|
let channel_1 = db
|
|
.create_channel("channel", None, "room", user)
|
|
.await
|
|
.unwrap();
|
|
|
|
let channel_2 = db
|
|
.create_channel("channel-2", None, "room", user)
|
|
.await
|
|
.unwrap();
|
|
|
|
db.invite_channel_member(channel_1, observer, user, false)
|
|
.await
|
|
.unwrap();
|
|
|
|
db.respond_to_channel_invite(channel_1, observer, true)
|
|
.await
|
|
.unwrap();
|
|
|
|
db.invite_channel_member(channel_2, observer, user, false)
|
|
.await
|
|
.unwrap();
|
|
|
|
db.respond_to_channel_invite(channel_2, observer, true)
|
|
.await
|
|
.unwrap();
|
|
|
|
let owner_id = db.create_server("test").await.unwrap().0 as u32;
|
|
let user_connection_id = rpc::ConnectionId { owner_id, id: 0 };
|
|
|
|
db.join_channel_chat(channel_1, user_connection_id, user)
|
|
.await
|
|
.unwrap();
|
|
|
|
let _ = db
|
|
.create_channel_message(channel_1, user, "1_1", OffsetDateTime::now_utc(), 1)
|
|
.await
|
|
.unwrap();
|
|
|
|
let (second_message, _, _) = db
|
|
.create_channel_message(channel_1, user, "1_2", OffsetDateTime::now_utc(), 2)
|
|
.await
|
|
.unwrap();
|
|
|
|
let (third_message, _, _) = db
|
|
.create_channel_message(channel_1, user, "1_3", OffsetDateTime::now_utc(), 3)
|
|
.await
|
|
.unwrap();
|
|
|
|
db.join_channel_chat(channel_2, user_connection_id, user)
|
|
.await
|
|
.unwrap();
|
|
|
|
let (fourth_message, _, _) = db
|
|
.create_channel_message(channel_2, user, "2_1", OffsetDateTime::now_utc(), 4)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Check that observer has new messages
|
|
let unseen_messages = db
|
|
.transaction(|tx| async move {
|
|
db.unseen_channel_messages(observer, &[channel_1, channel_2], &*tx)
|
|
.await
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
unseen_messages,
|
|
[
|
|
rpc::proto::UnseenChannelMessage {
|
|
channel_id: channel_1.to_proto(),
|
|
message_id: third_message.to_proto(),
|
|
},
|
|
rpc::proto::UnseenChannelMessage {
|
|
channel_id: channel_2.to_proto(),
|
|
message_id: fourth_message.to_proto(),
|
|
},
|
|
]
|
|
);
|
|
|
|
// Observe the second message
|
|
db.observe_channel_message(channel_1, observer, second_message)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Make sure the observer still has a new message
|
|
let unseen_messages = db
|
|
.transaction(|tx| async move {
|
|
db.unseen_channel_messages(observer, &[channel_1, channel_2], &*tx)
|
|
.await
|
|
})
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
unseen_messages,
|
|
[
|
|
rpc::proto::UnseenChannelMessage {
|
|
channel_id: channel_1.to_proto(),
|
|
message_id: third_message.to_proto(),
|
|
},
|
|
rpc::proto::UnseenChannelMessage {
|
|
channel_id: channel_2.to_proto(),
|
|
message_id: fourth_message.to_proto(),
|
|
},
|
|
]
|
|
);
|
|
|
|
// Observe the third message,
|
|
db.observe_channel_message(channel_1, observer, third_message)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Make sure the observer does not have a new method
|
|
let unseen_messages = db
|
|
.transaction(|tx| async move {
|
|
db.unseen_channel_messages(observer, &[channel_1, channel_2], &*tx)
|
|
.await
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
unseen_messages,
|
|
[rpc::proto::UnseenChannelMessage {
|
|
channel_id: channel_2.to_proto(),
|
|
message_id: fourth_message.to_proto(),
|
|
}]
|
|
);
|
|
|
|
// Observe the second message again, should not regress our observed state
|
|
db.observe_channel_message(channel_1, observer, second_message)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Make sure the observer does not have a new message
|
|
let unseen_messages = db
|
|
.transaction(|tx| async move {
|
|
db.unseen_channel_messages(observer, &[channel_1, channel_2], &*tx)
|
|
.await
|
|
})
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
unseen_messages,
|
|
[rpc::proto::UnseenChannelMessage {
|
|
channel_id: channel_2.to_proto(),
|
|
message_id: fourth_message.to_proto(),
|
|
}]
|
|
);
|
|
}
|