test: add tests to bot routes

crates/delta/src/util/test.rs

@@ -1,8 +1,19 @@
+use futures::StreamExt;
+use rand::Rng;
+use redis_kiss::redis::aio::PubSub;
+use revolt_database::{events::client::EventV1, Database, DatabaseInfo, User};
+use revolt_quark::authifier::{
+    models::{Account, Session},
+    Authifier,
+};
 use rocket::local::asynchronous::Client;
-use std::ops::Deref;
 
 pub struct TestHarness {
-    client: Client,
+    pub client: Client,
+    authifier: Authifier,
+    pub db: Database,
+    sub: PubSub,
+    event_buffer: Vec<EventV1>,
 }
 
 impl TestHarness {
@@ -13,14 +24,87 @@ impl TestHarness {
             .await
             .expect("valid rocket instance");
 
-        TestHarness { client }
-    }
-}
-
-impl Deref for TestHarness {
-    type Target = Client;
-
-    fn deref(&self) -> &Self::Target {
-        &self.client
+        let db = DatabaseInfo::Auto.connect().await.expect("`Database`");
+        let mut sub = redis_kiss::open_pubsub_connection()
+            .await
+            .expect("`PubSub`");
+
+        sub.psubscribe("*").await.unwrap();
+
+        TestHarness {
+            client,
+            authifier: Authifier {
+                database: db.clone().into(),
+                config: revolt_quark::util::authifier::config(),
+                event_channel: None,
+            },
+            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!()
     }
 }