refactor: test structure and add integration tests

Author: ImShyMike

rustytime/Cargo.lock

@@ -1,14 +1,18 @@
 [package]
 name = "rustytime-server"
 description = "🕒 blazingly fast time tracking for developers"
-version = "0.16.4"
+version = "0.17.0"
 edition = "2024"
 authors = ["ImShyMike"]
 readme = "../README.md"
 license = "AGPL-3.0-only"
 homepage = "https://rustytime.shymike.dev"
 repository = "https://github.com/ImShyMike/rustytime"
 
+[lib]
+name = "rustytime_server"
+path = "src/lib.rs"
+
 [[bin]]
 name = "rustytime"
 path = "src/main.rs"
@@ -34,10 +38,11 @@ debug = false
 [features]
 default = []
 seed = ["rand"]
+integration = []
 
 [dependencies]
 axum =  { version = "0.8.8", features = ["json", "query", "http1", "http2", "tokio", "macros"], default-features = false }
-diesel = { version = "2.3.5", features = ["32-column-tables", "chrono", "postgres", "uuid", "r2d2", "network-address"], default-features = false }
+diesel = { version = "2.3.6", features = ["32-column-tables", "chrono", "postgres", "uuid", "r2d2", "network-address"], default-features = false }
 diesel_migrations = { version = "2.3.1", default-features = false }
 tokio = { version = "1.49.0", features = ["signal", "rt-multi-thread"], default-features = false }
 tower-http = { version = "0.6.7", features = ["limit", "timeout", "trace", "cors", "normalize-path", "compression-gzip", "decompression-gzip"], default-features = false }
@@ -56,7 +61,7 @@ reqwest = { version = "0.13.1", features = ["json", "cookies", "query", "rustls"
 url = { version = "2.5.8", default-features = false }
 tower = { version = "0.5.3", default-features = false }
 tower-cookies = { version = "0.11.0", features = ["axum-core"], default-features = false }
-time = { version = "0.3.45", default-features = false }
+time = { version = "0.3.46", default-features = false }
 urlencoding = { version = "2.1.3", default-features = false }
 regex = { version = "1.12.2", default-features = false }
 once_cell = { version = "1.21.3", default-features = false }
@@ -82,3 +87,9 @@ cron = { version = "0.15.0", default-features = false }
 futures = { version = "0.3.31", default-features = false }
 sqlx = { version = "0.8.6", default-features = false }
 moka = { version = "0.12.10", features = ["sync"], default-features = false }
+
+[dev-dependencies]
+serde_urlencoded = { version = "0.7" }
+serde_qs = { version = "0.15.0" }
+axum-test = { version = "18.7.0" }
+tower = { version = "0.5", features = ["util"] }

rustytime/Cargo.toml

@@ -1,3 +1,5 @@
+use std::env;
+
 use aide::openapi::{
     ApiKeyLocation, Components, License, OpenApi, ReferenceOr, SecurityScheme, Server, Tag,
 };
@@ -20,7 +22,7 @@ pub fn get_openapi_docs() -> OpenApi {
 
     openapi.servers = vec![
         Server {
-            url: "https://api-rustytime.shymike.dev".into(),
+            url: env::var("PUBLIC_BACKEND_API_URL").unwrap_or_else(|_| "https://api-rustytime.shymike.dev".into()),
             description: Some("Production deployment".into()),
             ..Default::default()
         },

rustytime/src/docs.rs

@@ -16,6 +16,7 @@ use crate::jobs::import::enqueue_import;
 use crate::models::import_job::{ImportJob, ImportJobStatus};
 use crate::state::AppState;
 use crate::utils::extractors::AuthenticatedUser;
+use crate::utils::extractors::DbConnection;
 use crate::utils::session::SessionManager;
 
 #[derive(Deserialize, JsonSchema)]
@@ -66,6 +67,7 @@ pub async fn import_heartbeats(
     Query(query): Query<ImportQuery>,
     cookies: NoApi<Cookies>,
     NoApi(AuthenticatedUser(current_user)): NoApi<AuthenticatedUser>,
+    NoApi(DbConnection(mut conn)): NoApi<DbConnection>,
 ) -> Result<Json<ImportStartResponse>, Response> {
     let Some(session_id) = SessionManager::get_session_from_cookies(&cookies) else {
         return Err((StatusCode::UNAUTHORIZED, "User session is invalid").into_response());
@@ -97,7 +99,7 @@ pub async fn import_heartbeats(
 
     let user_id = current_user.id;
 
-    if let Ok(Some(active_job)) = ImportJob::get_active_for_user(&app_state.db_pool, user_id) {
+    if let Ok(Some(active_job)) = ImportJob::get_active_for_user(&mut conn, user_id) {
         return Err((
             StatusCode::CONFLICT,
             format!(
@@ -109,7 +111,7 @@ pub async fn import_heartbeats(
     }
 
     let import_job = db_query!(
-        ImportJob::create(&app_state.db_pool, user_id),
+        ImportJob::create(&mut conn, user_id),
         "Failed to create import job"
     );
 
@@ -125,7 +127,7 @@ pub async fn import_heartbeats(
 
     if let Err(e) = enqueue_import(store, user_id, api_key, import_job.id).await {
         error!(error = ?e, job_id = import_job.id, "Failed to enqueue import job");
-        let _ = ImportJob::fail(&app_state.db_pool, import_job.id, "Failed to enqueue job");
+        let _ = ImportJob::fail(&mut conn, import_job.id, "Failed to enqueue job");
         return Err((
             StatusCode::INTERNAL_SERVER_ERROR,
             "Failed to start import job",
@@ -147,13 +149,13 @@ pub async fn import_heartbeats(
 }
 
 pub async fn import_status(
-    State(app_state): State<AppState>,
     NoApi(AuthenticatedUser(current_user)): NoApi<AuthenticatedUser>,
+    NoApi(DbConnection(mut conn)): NoApi<DbConnection>,
 ) -> Result<Json<ImportStatusResponse>, Response> {
     let user_id = current_user.id;
 
     let job = db_query!(
-        ImportJob::get_latest_for_user(&app_state.db_pool, user_id),
+        ImportJob::get_latest_for_user(&mut conn, user_id),
         "Failed to get import job"
     );
 
@@ -162,32 +164,3 @@ pub async fn import_status(
         None => Err((StatusCode::NOT_FOUND, "No import jobs found").into_response()),
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn import_status_response_from_job() {
-        use chrono::Utc;
-
-        let job = ImportJob {
-            id: 1,
-            user_id: 42,
-            status: "completed".to_string(),
-            imported_count: Some(100),
-            processed_count: Some(150),
-            request_count: Some(5),
-            start_date: Some("2024-01-01T00:00:00Z".to_string()),
-            time_taken: Some(12.5),
-            error_message: None,
-            created_at: Utc::now(),
-            updated_at: Utc::now(),
-        };
-
-        let response = ImportStatusResponse::from(job);
-        assert_eq!(response.job_id, 1);
-        assert_eq!(response.status, "completed");
-        assert_eq!(response.imported_count, Some(100));
-    }
-}

rustytime/src/handlers/data/import.rs

@@ -1,15 +1,14 @@
 use aide::NoApi;
 use axum::Json;
 use axum::extract::Query;
-use axum::{extract::State, http::StatusCode, response::IntoResponse, response::Response};
+use axum::{http::StatusCode, response::IntoResponse, response::Response};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use crate::db_query;
 use crate::models::import_job::ImportJob;
-use crate::models::user::User;
-use crate::state::AppState;
-use crate::utils::extractors::AuthenticatedUser;
+use crate::models::import_job::ImportJobWithUser;
+use crate::utils::extractors::{AuthenticatedUser, DbConnection};
 
 #[derive(Deserialize, JsonSchema)]
 pub struct ImportsQuery {
@@ -23,23 +22,6 @@ fn default_limit() -> i64 {
     50
 }
 
-#[derive(Serialize, JsonSchema)]
-pub struct ImportJobWithUser {
-    pub id: i64,
-    pub user_id: i32,
-    pub user_name: Option<String>,
-    pub user_avatar_url: Option<String>,
-    pub status: String,
-    pub imported_count: Option<i64>,
-    pub processed_count: Option<i64>,
-    pub request_count: Option<i32>,
-    pub start_date: Option<String>,
-    pub time_taken: Option<f64>,
-    pub error_message: Option<String>,
-    pub created_at: String,
-    pub updated_at: String,
-}
-
 #[derive(Serialize, JsonSchema)]
 pub struct AdminImportsResponse {
     pub imports: Vec<ImportJobWithUser>,
@@ -49,55 +31,27 @@ pub struct AdminImportsResponse {
 }
 
 pub async fn admin_imports(
-    State(app_state): State<AppState>,
     Query(query): Query<ImportsQuery>,
     NoApi(AuthenticatedUser(current_user)): NoApi<AuthenticatedUser>,
+    NoApi(DbConnection(mut conn)): NoApi<DbConnection>,
 ) -> Result<Json<AdminImportsResponse>, Response> {
-    if !current_user.is_admin() {
+    if !current_user.is_owner() {
         return Err((StatusCode::FORBIDDEN, "No permission").into_response());
     }
 
     let limit = query.limit.clamp(1, 100);
     let offset = query.offset.max(0);
 
     let total = db_query!(
-        ImportJob::count_all(&app_state.db_pool),
+        ImportJob::count_all(&mut conn),
         "Failed to count import jobs"
     );
 
-    let jobs = db_query!(
-        ImportJob::get_all(&app_state.db_pool, limit, offset),
+    let imports = db_query!(
+        ImportJob::get_all_with_users(&mut conn, limit, offset),
         "Failed to fetch import jobs"
     );
 
-    let user_ids: Vec<i32> = jobs.iter().map(|j| j.user_id).collect();
-    let users = db_query!(
-        User::get_by_ids(&app_state.db_pool, &user_ids),
-        "Failed to fetch users"
-    );
-
-    let imports: Vec<ImportJobWithUser> = jobs
-        .into_iter()
-        .map(|job| {
-            let user = users.iter().find(|u| u.id == job.user_id);
-            ImportJobWithUser {
-                id: job.id,
-                user_id: job.user_id,
-                user_name: user.map(|u| u.name.clone()),
-                user_avatar_url: user.map(|u| u.avatar_url.clone()),
-                status: job.status,
-                imported_count: job.imported_count,
-                processed_count: job.processed_count,
-                request_count: job.request_count,
-                start_date: job.start_date,
-                time_taken: job.time_taken,
-                error_message: job.error_message,
-                created_at: job.created_at.to_rfc3339(),
-                updated_at: job.updated_at.to_rfc3339(),
-            }
-        })
-        .collect();
-
     Ok(Json(AdminImportsResponse {
         imports,
         total,

rustytime/src/handlers/page/imports.rs

@@ -120,14 +120,16 @@ async fn run_import(job: ImportJob, pool: Data<DbPool>) -> Result<String, BoxDyn
 
     let elapsed = started.elapsed();
 
+    let conn = &mut *pool.get().expect("Failed to get DB connection from pool");
+
     match result {
         Ok((imported, processed, requests, earliest_requested)) => {
             let start_date = earliest_requested
                 .map(format_rfc3339)
                 .unwrap_or_else(|| cutoff.to_rfc3339_opts(SecondsFormat::Millis, true));
 
             if let Err(e) = ImportJobModel::complete(
-                &pool,
+                conn,
                 job_id,
                 imported as i64,
                 processed as i64,
@@ -154,7 +156,7 @@ async fn run_import(job: ImportJob, pool: Data<DbPool>) -> Result<String, BoxDyn
             ))
         }
         Err(error_message) => {
-            if let Err(e) = ImportJobModel::fail(&pool, job_id, &error_message) {
+            if let Err(e) = ImportJobModel::fail(conn, job_id, &error_message) {
                 error!(error = ?e, "Failed to update import job as failed");
             }
 

rustytime/src/jobs/import.rs

@@ -0,0 +1,12 @@
+#![forbid(unsafe_code)]
+#![cfg(feature = "integration")]
+
+pub mod db;
+pub mod docs;
+pub mod handlers;
+pub mod jobs;
+pub mod models;
+pub mod routes;
+pub mod schema;
+pub mod state;
+pub mod utils;