Merge pull request #20 from hackpulsar/integration-tests

Integration tests

Author: hackpulsar

Cargo.lock

@@ -22,4 +22,12 @@ tokio-util = { version = "0.7", features = ["io"] }
 rand = "0.8.0"
 log = "0.4"
 env_logger = "0.11"
-openssl = "0.10"
+openssl = "0.10"
+
+[dev-dependencies]
+testcontainers = "0.27"
+testcontainers-modules = { version = "0.15", features = ["postgres", "redis"]}
+tempfile = "3"
+serde_json = "1"
+actix-http = "3"
+actix-multipart-test = { git = "https://github.com/linasdev/actix-multipart-test", branch = "main"}

Cargo.toml

@@ -0,0 +1,32 @@
+pub mod models;
+pub mod routes;
+pub mod services;
+pub mod utils;
+
+use deadpool_redis::{Config, Runtime};
+use sqlx::{Postgres};
+use log::info;
+
+// Holds app state
+pub struct AppState {
+    pub secret: String,
+    pub db_pool: sqlx::Pool<Postgres>,
+    pub redis_pool: deadpool_redis::Pool,
+    pub storage_dir: String
+}
+
+// Connects to a database
+pub async fn create_db_pool(db_url: String) -> Result<sqlx::Pool<Postgres>, sqlx::Error> {
+    info!("Connecting to PostgreSQL...");
+    let pool = sqlx::postgres::PgPool::connect(db_url.as_str()).await?;
+    info!("Connected to PostgreSQL.");
+    Ok(pool)
+}
+
+// Creates a new redis pool
+pub fn create_redis_pool(redis_url: String) -> Result<deadpool_redis::Pool, deadpool_redis::CreatePoolError> {
+    info!("Connecting to Redis...");
+    let pool = Config::from_url(redis_url.as_str()).create_pool(Some(Runtime::Tokio1))?;
+    info!("Connected to Redis.");
+    Ok(pool)
+}

src/lib.rs

@@ -1,27 +1,14 @@
-mod models;
-mod routes;
-mod services;
-mod utils;
-
 use core::panic;
 
 use actix_multipart::form::tempfile::TempFileConfig;
 use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
 use actix_web::{App, HttpServer, web};
-use deadpool_redis::{Config, Runtime};
-use sqlx::{Postgres};
 use log::{info, error};
 
+use storage_crab::*;
 use crate::routes::init_routes;
 use crate::utils::generate_shared_secret;
 
-// Holds app state
-pub struct AppState {
-    secret: String,
-    db_pool: sqlx::Pool<Postgres>,
-    redis_pool: deadpool_redis::Pool,
-}
-
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
     // Loading environment variables
@@ -72,27 +59,12 @@ async fn main() -> std::io::Result<()> {
                 secret: secret.clone(),
                 db_pool: db_pool.clone(),
                 redis_pool: redis_pool.clone(),
+                storage_dir: std::env::var("FILES_STORAGE_PATH").unwrap()
             }))
-            .app_data(TempFileConfig::default().directory(std::env::var("FILES_STORAGE_PATH").unwrap()))
+            .app_data(TempFileConfig::default().directory(std::env::var("TMP_FILES_STORAGE").unwrap()))
             .configure(init_routes)
     })
     .bind_openssl("0.0.0.0:8080", builder)?
     .run()
     .await
 }
-
-// Connects to a database
-async fn create_db_pool(db_url: String) -> Result<sqlx::Pool<Postgres>, sqlx::Error> {
-    info!("Connecting to PostgreSQL...");
-    let pool = sqlx::postgres::PgPool::connect(db_url.as_str()).await?;
-    info!("Connected to PostgreSQL.");
-    Ok(pool)
-}
-
-// Creates a new redis pool
-fn create_redis_pool(redis_url: String) -> Result<deadpool_redis::Pool, deadpool_redis::CreatePoolError> {
-    info!("Connecting to Redis...");
-    let pool = Config::from_url(redis_url.as_str()).create_pool(Some(Runtime::Tokio1))?;
-    info!("Connected to Redis.");
-    Ok(pool)
-}

src/main.rs

@@ -20,7 +20,7 @@ pub struct FileUploadForm {
 }
 
 // A file in database
-#[derive(Serialize)]
+#[derive(Serialize, Deserialize)]
 pub struct DBFile {
     pub id: i32,
     pub filename: String,
@@ -30,13 +30,13 @@ pub struct DBFile {
     pub user_id: i32
 }
 
-#[derive(Serialize)]
+#[derive(Serialize, Deserialize)]
 pub struct FileUploadResponse {
     pub file_id: i32,
     pub path: String
 }
 
-#[derive(Serialize)]
+#[derive(Serialize, Deserialize)]
 pub struct FileShareResponse {
     pub code: String
 }
@@ -76,7 +76,7 @@ impl DBFile {
             }
             None => {
                 debug!("File with ID [{}] foesn't exist", id);
-                return Err(AppError::InternalServerError { msg: "File doesn't exist".to_string() })
+                return Err(AppError::NotFound { msg: "File doesn't exist".to_string() })
             }
         }
     }

src/models/file.rs

@@ -10,10 +10,10 @@ pub struct Claims {
     pub jti: String,           // token id
 }
 
-#[derive(Serialize)]
+#[derive(Serialize, Deserialize)]
 pub struct JwtTokenPair {
-    access_token: String,
-    refresh_token: String,
+    pub access_token: String,
+    pub refresh_token: String,
 }
 
 #[derive(Serialize, Deserialize, PartialEq, Debug)]

src/models/jwt.rs

@@ -11,14 +11,14 @@ pub struct DBUser {
 
 // Essential user information.
 // To be used externally.
-#[derive(Serialize)]
+#[derive(Serialize, Deserialize)]
 pub struct UserInfo {
     pub id: i32,
     pub email: String,
     pub username: String,
 }
 
-#[derive(Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct UserLoginCredentials {
     pub email: String,
     pub password_hash: String,

src/models/user.rs

@@ -95,7 +95,7 @@ async fn login(user: web::Json<UserLoginCredentials>, data: web::Data<AppState>)
         },
         None => {
             debug!("No user with credentials [{:?}]", user.into_inner());
-            Err(AppError::BadRequest { msg: "No user found with given credentials".to_string() })
+            Err(AppError::NotFound { msg: "No user found with given credentials".to_string() })
         }
     }
 }
@@ -120,23 +120,22 @@ async fn refresh_token(req: web::Json<RefreshRequest>, data: web::Data<AppState>
     }
 
     // Check if token is blacklisted
-    let mut conn = data.redis_pool
-        .get().await
+    let mut conn = data.redis_pool.get().await
         .map_err(|_| {
             warn!("Connection to Redis lost");
             AppError::InternalServerError { msg: "Connection to Redis lost".to_string() }
         })?;
 
     // If token exists in Redis, it is blacklisted
-    match conn.get::<_, Option<String>>(token.claims.jti.clone()).await.ok() {
-        Some(_) => {
+    match conn.get::<_, Option<String>>(token.claims.jti.clone()).await {
+        Ok(Some(_)) => {
             debug!("Token is blacklisted: [{:?}]", req.0);
             Err(AppError::BadRequest { msg: "Token is blacklisted".to_string() })
         }
-        None => {
+        Ok(None) => {
             // Blacklist token. 
             // Redis will delete this entry as soon as the token gets expired.
-            conn.set_ex::<_, _, ()>(
+            let _: () = conn.set_ex(
                 token.claims.jti.clone(),
                 req.refresh_token.clone(),
                 // saturating_sub wraps to zero to prevent underflow
@@ -153,5 +152,9 @@ async fn refresh_token(req: web::Json<RefreshRequest>, data: web::Data<AppState>
                 data.secret.clone()
             )))
         }
+        Err(_) => {
+            warn!("Faied to fetch token from Redis.");
+            Err(AppError::InternalServerError {msg: "Faied to fetch token from Redis.".to_string()})
+        }
     }
 }

src/routes/auth.rs

@@ -77,16 +77,15 @@ async fn upload_file(
     let username_hash = hex::encode(hasher.finalize());
 
     // Path to files storage
-    let storage_path = std::env::var("FILES_STORAGE_PATH").unwrap();
-    let path = format!("{}/{}/{}", storage_path, username_hash, form.json.filename.clone());
+    let path = format!("{}/{}/{}", data.storage_dir, username_hash, form.json.filename.clone());
 
     // Check if file already exists
     if Path::new(path.as_str()).exists() {
         debug!("File [{}] already exists", path);
         return Err(AppError::BadRequest { msg: "File with this name already exists".to_string() });
     }
 
-    let dir_path = format!("{}/{}", storage_path, username_hash);
+    let dir_path = format!("{}/{}", data.storage_dir, username_hash);
 
     // Create dirs for file of don't exist
     fs::create_dir_all(&dir_path).await
@@ -170,7 +169,7 @@ async fn download_shared_file(share_code: web::Path<String>, req: HttpRequest, d
         })?;
 
     // Validate the share code
-    let file_id = match conn.get::<_, Option<i32>>(share_code.clone()).await {
+    let file_id: i32 = match conn.get(share_code.clone()).await {
         Ok(Some(id)) => {
             debug!("File ID valid: {}", id);
             id
@@ -268,7 +267,7 @@ async fn share_file(file_id: web::Path<i32>, req: HttpRequest, data: web::Data<A
             AppError::InternalServerError { msg: "Connection to Redis lost".to_string() }
         })?;
 
-    // Delete the previous code if exists
+    // Delete the previous code if exists   
     if let Ok(Some(old_code)) = conn.get::<_, Option<String>>(file_id).await {
         // Delete old code key
         let _: () = conn.del(&old_code).await.map_err(|_| {
@@ -295,15 +294,15 @@ async fn share_file(file_id: web::Path<i32>, req: HttpRequest, data: web::Data<A
             Some(_) => { /* Key already exists, continue */ },
             None => {
                 // Code is unique, add it to redis with 5 minutes expiration time
-                conn.set_ex::<_, _, ()>(key, file_id, 5 * 60).await
+                let _:() = conn.set_ex(key, file_id, 5 * 60).await
                     .map_err(|_| {
                         warn!("Failed to save share code [{}]", share_code);
                         AppError::InternalServerError { msg: "Failed to save share code".to_string() }
                     })?;
 
                 // Reverse map, for accessing current share code for a file.
                 // Overwrites previous data.
-                conn.set_ex::<_, _, ()>(file_id, key, 5 * 60).await
+                let _:() = conn.set_ex(file_id, key, 5 * 60).await
                     .map_err(|_| {
                         warn!("Failed to save reverse mapping for share code [{}]", share_code);
                         AppError::InternalServerError { msg: "Failed to save reverse mapping for share code".to_string() }

src/routes/files.rs

@@ -15,6 +15,9 @@ pub enum AppError {
 
     #[display("Internal server error: {}", msg)]
     InternalServerError { msg: String },
+
+    #[display("Not found: {}", msg)]
+    NotFound { msg: String }
 }
 
 #[derive(Serialize)]
@@ -28,6 +31,7 @@ impl ResponseError for AppError {
             AppError::Unauthorized => StatusCode::UNAUTHORIZED,
             AppError::BadRequest { .. } => StatusCode::BAD_REQUEST,
             AppError::InternalServerError { .. } => StatusCode::INTERNAL_SERVER_ERROR,
+            AppError::NotFound { .. } => StatusCode::NOT_FOUND
         }
     }