6838b0b1f0
test: update authifier to allow for in-memory tests ci: explicitly run in-memory and mongo tests
118 lines
2.9 KiB
Rust
118 lines
2.9 KiB
Rust
use futures::StreamExt;
|
|
use rand::Rng;
|
|
use redis_kiss::redis::aio::PubSub;
|
|
use revolt_database::{events::client::EventV1, Database, User};
|
|
use revolt_quark::authifier::{
|
|
models::{Account, Session},
|
|
Authifier,
|
|
};
|
|
use rocket::local::asynchronous::Client;
|
|
|
|
pub struct TestHarness {
|
|
pub client: Client,
|
|
authifier: Authifier,
|
|
pub db: Database,
|
|
sub: PubSub,
|
|
event_buffer: Vec<EventV1>,
|
|
}
|
|
|
|
impl TestHarness {
|
|
pub async fn new() -> TestHarness {
|
|
dotenv::dotenv().ok();
|
|
|
|
let client = Client::tracked(crate::web().await)
|
|
.await
|
|
.expect("valid rocket instance");
|
|
|
|
let mut sub = redis_kiss::open_pubsub_connection()
|
|
.await
|
|
.expect("`PubSub`");
|
|
|
|
sub.psubscribe("*").await.unwrap();
|
|
|
|
let db = client
|
|
.rocket()
|
|
.state::<Database>()
|
|
.expect("`Database`")
|
|
.clone();
|
|
|
|
let authifier = client
|
|
.rocket()
|
|
.state::<Authifier>()
|
|
.expect("`Authifier`")
|
|
.clone();
|
|
|
|
TestHarness {
|
|
client,
|
|
authifier,
|
|
db,
|
|
sub,
|
|
event_buffer: vec![],
|
|
}
|
|
}
|
|
|
|
pub fn rand_string() -> String {
|
|
let mut rng = rand::thread_rng();
|
|
(&mut rng)
|
|
.sample_iter(rand::distributions::Alphanumeric)
|
|
.take(20)
|
|
.map(char::from)
|
|
.collect()
|
|
}
|
|
|
|
pub async fn new_user(&self) -> (Account, Session, User) {
|
|
let account = Account::new(
|
|
&self.authifier,
|
|
format!("{}@revolt.chat", TestHarness::rand_string()),
|
|
"password".to_string(),
|
|
false,
|
|
)
|
|
.await
|
|
.expect("`Account`");
|
|
|
|
let session = account
|
|
.create_session(&self.authifier, String::new())
|
|
.await
|
|
.expect("`Session`");
|
|
|
|
let user = User::create(
|
|
&self.db,
|
|
TestHarness::rand_string(),
|
|
account.id.to_string(),
|
|
None,
|
|
)
|
|
.await
|
|
.expect("`User`");
|
|
|
|
(account, session, user)
|
|
}
|
|
|
|
pub async fn wait_for_event<F>(&mut self, predicate: F) -> EventV1
|
|
where
|
|
F: Fn(&EventV1) -> bool,
|
|
{
|
|
for event in &self.event_buffer {
|
|
if predicate(event) {
|
|
// does not remove from buffer
|
|
return event.clone();
|
|
}
|
|
}
|
|
|
|
let mut stream = self.sub.on_message();
|
|
while let Some(item) = stream.next().await {
|
|
let payload: EventV1 = redis_kiss::decode_payload(&item.unwrap()).unwrap();
|
|
|
|
if predicate(&payload) {
|
|
return payload;
|
|
}
|
|
|
|
self.event_buffer.push(payload);
|
|
}
|
|
|
|
// WARNING: if predicate is never satisfied, this will never return
|
|
// should add a timeout for events so tests can fail gracefully
|
|
|
|
unreachable!()
|
|
}
|
|
}
|