diff --git a/.idea/dataSources.xml b/.idea/dataSources.xml index cf1fc59..75f69bb 100644 --- a/.idea/dataSources.xml +++ b/.idea/dataSources.xml @@ -5,7 +5,7 @@ postgresql true org.postgresql.Driver - jdbc:postgresql://localhost:32784/postgres + jdbc:postgresql://localhost:32769/postgres $ProjectFileDir$ diff --git a/Cargo.lock b/Cargo.lock index 46554eb..ea4671d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -441,18 +441,19 @@ dependencies = [ [[package]] name = "bon" -version = "2.0.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ea8256e3cff531086cc3faf94c1649930ff64bceb2d0e8cc84fc0356d7ee9806" +checksum = "811d7882589e047896e5974d039dd8823a67973a63d559e6ad1e87ff5c42ed4f" dependencies = [ "bon-macros", + "rustversion", ] [[package]] name = "bon-macros" -version = "2.0.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b99838f77c5073bc7846ecce92b64e7e5a5bd152a8ec392facf90ee4d90b4b35" +checksum = "d8e745a763e579a5ce70130e66f9dd35abf77cfeb9f418f305aeab8d1ae54c43" dependencies = [ "darling", "ident_case", @@ -1509,7 +1510,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" name = "lib" version = "1.4.3" dependencies = [ + "async-trait", "axum", + "bon", "chrono", "deadpool-diesel", "derive_more", @@ -1517,9 +1520,12 @@ dependencies = [ "diesel-async", "diesel-crud-derive", "diesel-crud-trait", + "diesel_async_migrations", "into-response-derive", "mime", "serde", + "serde_json", + "testcontainers-modules", "thiserror", "tokio", "tower 0.5.0", @@ -2841,15 +2847,14 @@ dependencies = [ [[package]] name = "tower-http" -version = "0.5.2" +version = "0.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e9cd434a998747dd2c4276bc96ee2e0c7a2eadf3cae88e52be55a05fa9053f5" +checksum = "8437150ab6bbc8c5f0f519e3d5ed4aa883a83dd4cdd3d1b21f9482936046cb97" dependencies = [ "bitflags 2.6.0", "bytes", "http", "http-body", - "http-body-util", "pin-project-lite", "tower-layer", "tower-service", diff --git a/Cargo.toml b/Cargo.toml index 8996b1f..a51d48f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -45,6 +45,7 @@ lib = { path = "../lib", features = ["axum", "serde", "derive", "diesel", "time" #lib = { git = "https://github.com/emberal/rust-lib", tag = "1.4.3", features = ["axum", "serde", "derive"] } [dev-dependencies] +lib = { path = "../lib", features = ["test"] } rstest = "0.22.0" testcontainers-modules = { version = "0.10.0", features = ["postgres"] } async-std = { version = "1.12.0", features = ["attributes"] } diff --git a/src/database.rs b/src/database.rs index b559a62..f48ef8e 100644 --- a/src/database.rs +++ b/src/database.rs @@ -1,35 +1,10 @@ use crate::config; -use crate::error::AppError; -use axum::async_trait; use deadpool_diesel::postgres::BuildError; -use deadpool_diesel::Status; -use diesel_async::pooled_connection::deadpool::{Object, Pool}; -use diesel_async::pooled_connection::AsyncDieselConnectionManager; -use diesel_async::AsyncPgConnection; - -pub type PgPool = Pool; - -#[async_trait] -pub trait GetConnection: Clone + Send + Sync { - async fn get(&self) -> Result, AppError>; - fn status(&self) -> Status; -} - -#[async_trait] -impl GetConnection for PgPool { - async fn get(&self) -> Result, AppError> { - self.get().await.map_err(Into::into) - } - fn status(&self) -> Status { - self.status() - } -} +use lib::diesel::pool::PgPool; pub(crate) fn create_pool() -> Result { - create_pool_from_url(config::DATABASE_URL) -} - -pub(crate) fn create_pool_from_url(url: impl Into) -> Result { - let config = AsyncDieselConnectionManager::::new(url); - Pool::builder(config).max_size(config::POOL_SIZE).build() + lib::diesel::pool::create_pool() + .url(config::DATABASE_URL) + .size(config::POOL_SIZE) + .call() } diff --git a/src/error.rs b/src/error.rs index 75deff2..da1dc2b 100644 --- a/src/error.rs +++ b/src/error.rs @@ -1,11 +1,11 @@ +use crate::services::reservation_service::ReservationError; use axum::http::StatusCode; use axum::response::{IntoResponse, Response}; use axum_login::AuthnBackend; use derive_more::Constructor; use diesel::result::DatabaseErrorKind; use diesel_async::pooled_connection::deadpool; - -use crate::services::reservation_service::ReservationError; +use lib::diesel::get_connection::GetConnectionError; use lib::diesel_crud_trait::CrudError; use lib::into_response_derive::IntoResponse; use serde::{Deserialize, Serialize}; @@ -96,6 +96,15 @@ impl IntoResponse for ResponseError { } } +impl From for ResponseError { + fn from(value: GetConnectionError) -> Self { + match value { + GetConnectionError::PoolError(error) => Self::InternalServerError(error.to_string()), + GetConnectionError::DieselError(error) => Self::InternalServerError(error.to_string()), + } + } +} + impl From for ResponseError { fn from(value: CrudError) -> Self { match &value { @@ -156,6 +165,15 @@ impl IntoResponse for AppError { } } +impl From for AppError { + fn from(value: GetConnectionError) -> Self { + match value { + GetConnectionError::PoolError(error) => Self::PoolError(error), + GetConnectionError::DieselError(error) => Self::DatabaseError(error), + } + } +} + impl From for AppError { fn from(value: base64ct::Error) -> Self { Self::Base64Error(value.to_string()) diff --git a/src/main.rs b/src/main.rs index aadd46b..539deb6 100644 --- a/src/main.rs +++ b/src/main.rs @@ -2,13 +2,16 @@ #[macro_use] extern crate rstest; -use crate::database::{create_pool, GetConnection}; +use crate::database::create_pool; use crate::services::session_service::SessionService; use crate::services::user_service::UserService; +use axum::middleware::{from_fn, Next}; +use axum::response::IntoResponse; use axum::Router; use axum_login::tower_sessions::SessionManagerLayer; use axum_login::AuthManagerLayerBuilder; use lib::axum::app::AppBuilder; +use lib::diesel::get_connection::GetConnection; use tower_sessions::cookie::time::Duration; use tower_sessions::Expiry; @@ -73,7 +76,7 @@ async fn main() { trait LoginRequired { fn login_required(self) -> Self where - Pool: GetConnection + Send + Sync + 'static; + Pool: GetConnection + 'static; } impl LoginRequired for Router @@ -84,10 +87,6 @@ where where Pool: GetConnection + Send + Sync + 'static, { - use axum_login::axum::{ - middleware::{from_fn, Next}, - response::IntoResponse, - }; self.route_layer(from_fn( |auth_session: axum_login::AuthSession>, req, next: Next| async move { if auth_session.user.is_some() { diff --git a/src/routes/auth.rs b/src/routes/auth.rs index 72cef36..33f69ff 100644 --- a/src/routes/auth.rs +++ b/src/routes/auth.rs @@ -1,5 +1,5 @@ use crate::auth::AuthSession; -use crate::database::GetConnection; +use crate::error::ResponseError; use crate::models::user::{CreateUser, User, UserCredentials}; use crate::result::{ResponseResult, Success}; use crate::services::user_service::UserService; @@ -7,17 +7,17 @@ use crate::{bad_request, internal_server_error, ok}; use axum::extract::State; use axum::Json; use axum_valid::Valid; +use lib::diesel::get_connection::GetConnection; // router!( // "/auth", // routes!( // post "/login" => login::, // post "/register" => register:: // ), -// Pool: Clone, Send, Sync, GetConnection -> UserService +// Pool: GetConnection -> UserService // ); -pub fn router( -) -> axum::Router> { +pub fn router() -> axum::Router> { axum::Router::new().nest( "/auth", axum::Router::new() @@ -53,7 +53,7 @@ where .insert(create_user) .await .map(Success::Created) - .map_err(Into::into) + .map_err(ResponseError::from) } #[cfg(test)] @@ -61,26 +61,51 @@ mod tests { use crate::create_app; use crate::error::ErrorResponseBody; use crate::models::user::{CreateUser, User, UserRole}; - use crate::test::{create_test_containers_pool, create_test_pool, BuildJson, DeserializeInto}; + use crate::test::create_test_containers_pool; use axum::http::request::Builder; use axum::http::{Request, StatusCode}; + use axum::Router; + use futures::executor::block_on; + use lib::axum::traits::BuildJson; + use lib::serde::traits::DeserializeInto; use secrecy::ExposeSecret; use serde::ser::SerializeStruct; use serde::{Serialize, Serializer}; + use testcontainers_modules::postgres::Postgres; + use testcontainers_modules::testcontainers::ContainerAsync; use tower::ServiceExt; fn register() -> Builder { Request::builder().uri("/auth/register").method("POST") } - #[tokio::test] - async fn test_register_created() { - let pool = create_test_pool().await.unwrap(); - let app = create_app(pool); - let create_user = CreateUser::new("test@email.com", "password"); + #[fixture] + #[once] + fn setup() -> Setup { + block_on(async { + let test_container = create_test_containers_pool().await.unwrap(); + let app = create_app(test_container.pool); + Setup { + _container: test_container.container, + app, + } + }) + } + + struct Setup { + _container: ContainerAsync, + app: Router, + } + + #[rstest] + #[tokio::test(flavor = "multi_thread")] + async fn test_register_created(setup: &Setup) { + let create_user = CreateUser::new("test_register_created@email.com", "password"); let create_email = create_user.email.clone(); - let response = app + let response = setup + .app + .clone() .oneshot(register().json(create_user).unwrap()) .await .unwrap(); @@ -95,15 +120,18 @@ mod tests { assert!(!user.salt.is_empty()); } - #[tokio::test] - async fn test_register_email_already_registered() { - let test_container = create_test_containers_pool().await.unwrap(); - let app = create_app(test_container.pool); - - let create_user = CreateUser::new("test@email.com", "password"); + #[rstest] + #[tokio::test(flavor = "multi_thread")] + async fn test_register_email_already_registered(setup: &Setup) { + let create_user = CreateUser::new( + "test_register_email_already_registered@email.com", + "password", + ); let call = || async { - app.clone() + setup + .app + .clone() .oneshot(register().json(create_user.clone()).unwrap()) .await .unwrap() @@ -129,7 +157,7 @@ mod tests { where S: Serializer, { - let mut s = serializer.serialize_struct("CreateUser", 2)?; + let mut s = serializer.serialize_struct("CreateUser", 3)?; s.serialize_field("email", &self.email)?; s.serialize_field("password", &self.password.expose_secret())?; s.serialize_field("role", &self.role)?; diff --git a/src/services/reservation_service.rs b/src/services/reservation_service.rs index ac5b7b4..b073b38 100644 --- a/src/services/reservation_service.rs +++ b/src/services/reservation_service.rs @@ -115,28 +115,27 @@ mod tests { use crate::models::room::Room; use crate::models::user::{CreateUser, User}; use crate::schema::{hotel, room, user}; - use crate::test::setup_test_transaction; + use crate::test::create_test_containers_pool; use chrono::{Duration, Utc}; use diesel::dsl::insert_into; use diesel_async::AsyncPgConnection; + use futures::executor::block_on; + use lib::diesel::pool::PgPool; use lib::diesel_crud_trait::{DieselCrudCreate, DieselCrudRead}; use secrecy::SecretString; + use testcontainers_modules::postgres::Postgres; + use testcontainers_modules::testcontainers::ContainerAsync; #[rstest] - #[tokio::test] - async fn test_check_in(#[future] setup: Setup) { - let Setup { - mut conn, - reservation, - .. - } = setup.await; - - Reservation::check_in(reservation.id, &mut conn) + #[tokio::test(flavor = "multi_thread")] + async fn test_check_in(setup: &Setup) { + let mut conn = setup.pool.get().await.unwrap(); + Reservation::check_in(setup.reservation.id, &mut conn) .await .unwrap(); assert!( - Reservation::read(reservation.id, &mut conn) + Reservation::read(setup.reservation.id, &mut conn) .await .unwrap() .checked_in @@ -144,20 +143,15 @@ mod tests { } #[rstest] - #[tokio::test] - async fn test_check_out(#[future] setup: Setup) { - let Setup { - mut conn, - reservation, - .. - } = setup.await; - - Reservation::check_out(reservation.id, &mut conn) + #[tokio::test(flavor = "multi_thread")] + async fn test_check_out(setup: &Setup) { + let mut conn = setup.pool.get().await.unwrap(); + Reservation::check_out(setup.reservation.id, &mut conn) .await .unwrap(); assert!( - !Reservation::read(reservation.id, &mut conn) + !Reservation::read(setup.reservation.id, &mut conn) .await .unwrap() .checked_in @@ -190,40 +184,34 @@ mod tests { Duration::days(11), Err(ReservationError::RoomNotAvailable) )] - #[tokio::test] + #[tokio::test(flavor = "multi_thread")] async fn test_room_available( - #[future] setup: Setup, + setup: &Setup, #[case] start: Duration, #[case] end: Duration, #[case] expected: Result<(), ReservationError>, ) { - let Setup { - mut conn, - reservation, - .. - } = setup.await; + let mut conn = setup.pool.get().await.unwrap(); let now = Utc::now().naive_utc(); let start = now + start; let end = now + end; assert_eq!( - Reservation::room_available(reservation.room_id, (start, end).into(), &mut conn).await, + Reservation::room_available(setup.reservation.room_id, (start, end).into(), &mut conn) + .await, expected ); } #[rstest] - #[tokio::test] - async fn test_room_available_no_reservations(#[future] setup: Setup) { - let Setup { - mut conn, hotel, .. - } = setup.await; - + #[tokio::test(flavor = "multi_thread")] + async fn test_room_available_no_reservations(setup: &Setup) { + let mut conn = setup.pool.get().await.unwrap(); let room = Room::insert( Room { id: 2, - hotel_id: hotel.id, + hotel_id: setup.hotel.id, beds: 1, size: 1, }, @@ -243,21 +231,30 @@ mod tests { } #[fixture] - async fn setup() -> Setup { - let mut conn = setup_test_transaction().await.unwrap(); - let hotel = insert_hotel(&mut conn).await; - let user = insert_user(&mut conn).await; - let room = insert_room(&mut conn, hotel.id).await; - let reservation = insert_reservation(&mut conn, room.id, user.email).await; - Setup { - conn, - hotel, - reservation, - } + #[once] + fn setup() -> Setup { + block_on(async { + let test_container = create_test_containers_pool().await.unwrap(); + let pool = test_container.pool; + let mut conn = pool.get().await.unwrap(); + + let hotel = insert_hotel(&mut conn).await; + let user = insert_user(&mut conn).await; + let room = insert_room(&mut conn, hotel.id).await; + let reservation = insert_reservation(&mut conn, room.id, user.email).await; + + Setup { + _container: test_container.container, + pool, + hotel, + reservation, + } + }) } struct Setup { - conn: AsyncPgConnection, + _container: ContainerAsync, + pool: PgPool, hotel: Hotel, reservation: Reservation, } diff --git a/src/services/room_service.rs b/src/services/room_service.rs index 5a60c45..450bab7 100644 --- a/src/services/room_service.rs +++ b/src/services/room_service.rs @@ -55,13 +55,14 @@ impl Room { #[cfg(test)] mod tests { use super::*; + use crate::config; use crate::models::hotel::{CreateHotel, Hotel}; use crate::models::reservation::{CreateReservation, Reservation}; use crate::models::room::Room; use crate::models::user::{CreateUser, User}; - use crate::test::setup_test_transaction; use diesel_async::AsyncPgConnection; use lib::diesel_crud_trait::DieselCrudCreate; + use lib::test::diesel_pool::setup_test_transaction; use serde_json::json; #[rstest] @@ -148,7 +149,7 @@ mod tests { #[fixture] async fn setup() -> Setup { - let mut conn = setup_test_transaction().await.unwrap(); + let mut conn = setup_test_transaction(config::DATABASE_URL).await.unwrap(); let hotels = insert_hotels(&mut conn).await; let rooms = insert_rooms(&mut conn, &hotels).await; let _reservation = insert_reservation(&mut conn, rooms[0].id).await; diff --git a/src/test.rs b/src/test.rs index eda1ac6..4c45958 100644 --- a/src/test.rs +++ b/src/test.rs @@ -1,78 +1,11 @@ use crate::config; -use crate::database::{create_pool, create_pool_from_url, GetConnection, PgPool}; -use crate::error::AppError; -use axum::async_trait; -use axum::body::{to_bytes, Body}; -use axum::http::header::CONTENT_TYPE; -use axum::http::Request; -use axum::response::Response; -use deadpool_diesel::postgres::BuildError; -use deadpool_diesel::Status; -use derive_more::Constructor; -use diesel_async::pooled_connection::deadpool::{Object, PoolError}; -use diesel_async::{AsyncConnection, AsyncPgConnection}; -use mime::APPLICATION_JSON; -use serde::{Deserialize, Serialize}; -use serde_json::json; -use testcontainers_modules::postgres::Postgres; -use testcontainers_modules::testcontainers::runners::AsyncRunner; -use testcontainers_modules::testcontainers::{ContainerAsync, TestcontainersError}; -use thiserror::Error; - -#[derive(Debug, PartialEq, Error)] -pub enum Error { - #[error(transparent)] - Connection(#[from] diesel::ConnectionError), - #[error(transparent)] - Database(#[from] diesel::result::Error), -} - -pub async fn setup_test_transaction() -> Result { - let mut conn = AsyncPgConnection::establish(config::DATABASE_URL).await?; - conn.begin_test_transaction().await?; - Ok(conn) -} - -pub(crate) async fn create_test_pool() -> Result { - let pool = create_pool()?; - Ok(PoolStub(pool)) -} - -#[derive(Debug, Error)] -pub(crate) enum ContainerError { - #[error(transparent)] - TestContainers(#[from] TestcontainersError), - #[error(transparent)] - BuildError(#[from] BuildError), - #[error(transparent)] - PoolError(#[from] PoolError), - #[error(transparent)] - DieselError(#[from] diesel::result::Error), -} - -/// When the TestContainer is dropped, the container will be removed. -/// # Panics -/// If destructed and the container field is dropped, the container will be removed, and using the pool will cause panic. -#[derive(Constructor)] -pub(crate) struct TestContainer { - pub _container: ContainerAsync, - pub pool: PgPool, -} +use diesel_async::AsyncPgConnection; +use lib::test::test_containers::{ContainerError, TestContainer}; pub(crate) async fn create_test_containers_pool<'a>() -> Result { - let container = create_postgres_container().await?; - let connection_string = format!( - "postgres://postgres:postgres@127.0.0.1:{}/postgres", - container.get_host_port_ipv4(5432).await? - ); - let pool = create_pool_from_url(connection_string)?; - run_migrations(pool.get().await?.as_mut()).await?; - Ok(TestContainer::new(container, pool)) -} - -pub(crate) async fn create_postgres_container( -) -> Result, TestcontainersError> { - Postgres::default().start().await + let test_container = lib::test::test_containers::create_test_containers_pool().await?; + run_migrations(test_container.pool.get().await?.as_mut()).await?; + Ok(test_container) } pub(crate) async fn run_migrations( @@ -80,50 +13,3 @@ pub(crate) async fn run_migrations( ) -> Result<(), diesel::result::Error> { config::MIGRATIONS.run_pending_migrations(conn).await } - -#[derive(Clone)] -pub(crate) struct PoolStub(PgPool); - -#[async_trait] -impl GetConnection for PoolStub { - async fn get(&self) -> Result, AppError> { - let mut conn = self.0.get().await?; - conn.begin_test_transaction().await?; - Ok(conn) - } - fn status(&self) -> Status { - unimplemented!("PoolStub does not support status") - } -} - -pub trait BuildJson { - fn json(self, body: T) -> Result, axum::http::Error>; -} - -impl BuildJson for axum::http::request::Builder { - fn json(self, body: T) -> Result, axum::http::Error> { - self.header(CONTENT_TYPE, APPLICATION_JSON.as_ref()) - .body(Body::new(json!(body).to_string())) - } -} - -#[derive(Debug, Error)] -pub(crate) enum DeserializeError { - #[error(transparent)] - SerdeError(#[from] serde_json::Error), - #[error(transparent)] - AxumError(#[from] axum::Error), -} - -#[async_trait] -pub trait DeserializeInto { - async fn deserialize_into Deserialize<'de>>(self) -> Result; -} - -#[async_trait] -impl DeserializeInto for Response { - async fn deserialize_into Deserialize<'de>>(self) -> Result { - let body = to_bytes(self.into_body(), usize::MAX).await?; - serde_json::from_slice(&body).map_err(Into::into) - } -}