feat: tests and big refactor

tests/common/mod.rs

@@ -0,0 +1,86 @@
+use std::{net::{Ipv4Addr, SocketAddrV4, TcpListener}, sync::Arc, time::{SystemTime, UNIX_EPOCH}};
+
+use sea_orm::{ActiveModelTrait, ActiveValue::{NotSet, Set}, ColumnTrait, ConnectionTrait, Database, DatabaseConnection, EntityTrait, QueryFilter};
+
+use alexandria::{create_tables, entities::{owner, prelude::*, user}, routes::auth::{generate_token_from_claims, Claims, DEFAULT_TOKEN_EXPIRY_TIME}, run_server, utils::auth::hash_password};
+
+pub struct SetupData {
+    /// A valid JWT for testing features that need authentication
+    pub jwt: String,
+    pub api_path: String
+}
+
+/// Common setup function for tests that require a database and server setup
+pub async fn setup() -> SetupData {
+    let _ = pretty_env_logger::try_init();
+
+    let db: Arc<DatabaseConnection> = Arc::new(
+        match Database::connect(format!("sqlite::memory:?mode=rwc")).await {
+            Ok(c) => c,
+            Err(e) => {
+                panic!("Error while opening fatabase: {}", e.to_string())
+            }
+    });
+
+    create_tables(db.as_ref()).await.expect("Create tables should not fail");
+
+    let port = free_local_ipv4_port().expect("Could not get a free port");
+    let db_c = db.clone();
+    tokio::spawn(async move {
+        run_server(db_c, port, false).await;
+    });
+
+    create_user(db.as_ref(), "test_username", "test_password").await;
+
+
+    let unix_timestamp = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time should go forward").as_secs();
+
+    let claims = Claims {
+        sub: "test_username".to_string(),
+        exp: unix_timestamp + DEFAULT_TOKEN_EXPIRY_TIME,
+        user_id: 1
+    };
+
+    SetupData {
+        jwt: generate_token_from_claims(claims),
+        api_path: format!("http://0.0.0.0:{port}/api")
+    }
+}
+
+
+fn free_local_ipv4_port() -> Option<u16> {
+    let socket = SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0);
+    TcpListener::bind(socket)
+        .and_then(|listener| listener.local_addr())
+        .map(|addr| addr.port())
+        .ok()
+}
+
+async fn create_user<C>(db_conn: &C, username_t: impl ToString, password_t: impl ToString)
+where C: ConnectionTrait {
+    let username = username_t.to_string();
+    if User::find().filter(user::Column::Username.eq(username.clone())).one(db_conn).await.is_ok_and(|r| r.is_some()) {
+        panic!("Username {username} already in use");
+    } else {
+        let password = password_t.to_string();
+        let mut new_user = user::ActiveModel {
+            id: NotSet,
+            username: Set(username.clone()),
+            hashed_password: Set(hash_password(password)),
+            current_bal_id: Set(None),
+            owner_id: Set(None)
+        };
+        let res = new_user.clone().insert(db_conn).await.unwrap();
+
+        let new_owner = owner::ActiveModel {
+            id: NotSet,
+            user_id: Set(res.id),
+            first_name: Set(format!("{username} first name")),
+            last_name: Set(format!("{username} last name")),
+            contact: Set(format!("{username}@mail.com"))
+        };
+        let owner_res = new_owner.insert(db_conn).await.unwrap();
+        new_user.owner_id = Set(Some(owner_res.id));
+        let _ = new_user.update(db_conn);
+    }
+}