chore: tests

crates/matrix/src/admin/resources/user.rs

@@ -141,7 +141,6 @@ impl User {
         let resp = client
             .get_query("/_synapse/admin/v2/users", &params)
             .await?;
-        println!("{:?}", resp);
         let data: ListUsersResponse = resp.json().await?;
 
         Ok(data)

crates/server/src/config.rs

@@ -1,5 +1,10 @@
 use commune::CommuneConfig;
 
+pub const COMMUNE_SYNAPSE_HOST: &str = "COMMUNE_SYNAPSE_HOST";
+pub const COMMUNE_SYNAPSE_ADMIN_TOKEN: &str = "COMMUNE_SYNAPSE_ADMIN_TOKEN";
+pub const COMMUNE_SYNAPSE_SERVER_NAME: &str = "COMMUNE_SYNAPSE_SERVER_NAME";
+pub const COMMUNE_REGISTRATION_SHARED_SECRET: &str = "COMMUNE_REGISTRATION_SHARED_SECRET";
+
 pub struct ServerConfig {
     pub synapse_host: String,
     pub synapse_admin_token: String,
@@ -10,10 +15,10 @@ pub struct ServerConfig {
 impl ServerConfig {
     pub fn from_env() -> ServerConfig {
         ServerConfig {
-            synapse_host: Self::var("COMMUNE_SYNAPSE_HOST"),
-            synapse_admin_token: Self::var("COMMUNE_SYNAPSE_ADMIN_TOKEN"),
-            synapse_server_name: Self::var("COMMUNE_SYNAPSE_SERVER_NAME"),
-            synapse_registration_shared_secret: Self::var("COMMUNE_REGISTRATION_SHARED_SECRET"),
+            synapse_host: Self::var(COMMUNE_SYNAPSE_HOST),
+            synapse_admin_token: Self::var(COMMUNE_SYNAPSE_ADMIN_TOKEN),
+            synapse_server_name: Self::var(COMMUNE_SYNAPSE_SERVER_NAME),
+            synapse_registration_shared_secret: Self::var(COMMUNE_REGISTRATION_SHARED_SECRET),
         }
     }
 

crates/test/Cargo.toml

@@ -19,5 +19,6 @@ tokio = { workspace = true, features = ["rt", "rt-multi-thread", "macros"] }
 url = { workspace = true }
 
 # Local Dependencies
+core = { path = "../core" }
 matrix = { path = "../matrix" }
 server = { path = "../server" }

crates/test/src/matrix/shared_token_registration.rs

@@ -6,13 +6,13 @@ use crate::tools::environment::Environment;
 
 #[tokio::test]
 async fn creates_user_using_shared_secret() {
-    let env = Environment::new();
+    let env = Environment::new().await;
     let nonce = SharedSecretRegistration::get_nonce(&env.client)
         .await
         .unwrap()
         .nonce;
     let mac = SharedSecretRegistration::generate_mac(
-        env.registration_shared_secret,
+        env.config.synapse_registration_shared_secret.clone(),
         nonce.clone(),
         "steve".into(),
         "verysecure".into(),

crates/test/src/server/api/v1/account/login.rs

@@ -0,0 +1,45 @@
+use reqwest::StatusCode;
+
+use commune::account::service::CreateAccountDto;
+use commune_server::router::api::v1::account::login::{AccountLoginPayload, AccountLoginResponse};
+
+use crate::tools::environment::Environment;
+use crate::tools::http::HttpClient;
+
+#[tokio::test]
+async fn logs_into_account() {
+    let environment = Environment::new().await;
+
+    let username = "lucy".to_string();
+    let password = "P@ssW0Rd$".to_string();
+
+    environment
+        .commune
+        .account
+        .register(CreateAccountDto {
+            username: username.clone(),
+            password: password.clone().into(),
+            email: "lucyinthesky@gmail.com".to_string(),
+            session: "TEST".to_string(),
+            code: "TEST".to_string(),
+        })
+        .await
+        .unwrap();
+
+    let http_client = HttpClient::new().await;
+
+    let response = http_client
+        .post("/api/v1/account/login")
+        .json(&AccountLoginPayload { username, password })
+        .send()
+        .await;
+    let response_status = response.status();
+    let response_payload = response.json::<AccountLoginResponse>().await;
+
+    assert_eq!(
+        response_status,
+        StatusCode::OK,
+        "should return 200 for successful login"
+    );
+    assert!(!response_payload.access_token.is_empty(),)
+}

crates/test/src/server/api/v1/account/mod.rs

@@ -1 +1,2 @@
 mod create;
+mod login;

crates/test/src/tools/environment.rs

@@ -1,28 +1,40 @@
 use std::env::var;
 
+use commune::{Commune, CommuneConfig};
+use commune_server::config::{
+    COMMUNE_REGISTRATION_SHARED_SECRET, COMMUNE_SYNAPSE_ADMIN_TOKEN, COMMUNE_SYNAPSE_HOST,
+    COMMUNE_SYNAPSE_SERVER_NAME,
+};
 use matrix::Client;
 
-const COMMUNE_REGISTRATION_SHARED_SECRET: &str = "COMMUNE_REGISTRATION_SHARED_SECRET";
-const COMMUNE_SYNAPSE_HOST: &str = "COMMUNE_SYNAPSE_HOST";
-const COMMUNE_SYNAPSE_SERVER_NAME: &str = "COMMUNE_SYNAPSE_SERVER_NAME";
-
 pub struct Environment {
     pub client: Client,
-    pub registration_shared_secret: String,
+    pub commune: Commune,
+    pub config: CommuneConfig,
 }
 
 impl Environment {
-    pub fn new() -> Self {
+    pub async fn new() -> Self {
         dotenv::dotenv().ok();
 
         let synapse_host = Self::env_var(COMMUNE_SYNAPSE_HOST);
         let synapse_server_name = Self::env_var(COMMUNE_SYNAPSE_SERVER_NAME);
-        let client = Client::new(synapse_host, synapse_server_name).unwrap();
-        let registration_shared_secret = Self::env_var(COMMUNE_REGISTRATION_SHARED_SECRET);
+        let synapse_admin_token = Self::env_var(COMMUNE_SYNAPSE_ADMIN_TOKEN);
+        let synapse_registration_shared_secret = Self::env_var(COMMUNE_REGISTRATION_SHARED_SECRET);
+        let client = Client::new(synapse_host.clone(), synapse_server_name.clone()).unwrap();
+
+        let config = CommuneConfig {
+            synapse_host,
+            synapse_admin_token,
+            synapse_server_name,
+            synapse_registration_shared_secret,
+        };
+        let commune = Commune::new(config.clone()).await.unwrap();
 
         Self {
             client,
-            registration_shared_secret,
+            commune,
+            config,
         }
     }