Fix creating address, move to transactional tests

actors/database_manager/src/account_addresses.rs

@@ -70,8 +70,6 @@ WHERE account_id = $1 AND id = $2
     .map_err(|_| Error::AccountAddresses.into())
 }
 
-/////
-
 #[derive(actix::Message)]
 #[rtype(result = "Result<model::AccountAddress>")]
 pub struct DefaultAccountAddress {
@@ -139,14 +137,15 @@ WHERE account_id = $1
         .fetch_all(&mut *pool)
         .await
         {
-            log::error!("{}", e);
+            log::error!("{e}");
+            eprintln!("{e}")
         }
     }
 
     sqlx::query_as(
         r#"
-INSERT INTO account_addresses ( name, email, phone, street, city, country, zip, account_id )
+INSERT INTO account_addresses ( name, email, phone, street, city, country, zip, account_id, is_default)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
 RETURNING id, name, email, phone, street, city, country, zip, account_id, is_default
     "#,
     )
@@ -161,7 +160,11 @@ RETURNING id, name, email, phone, street, city, country, zip, account_id, is_def
     .bind(msg.is_default)
     .fetch_one(pool)
     .await
-    .map_err(|_| Error::CreateAccountAddress.into())
+    .map_err(|e| {
+        log::error!("{e}");
+        eprintln!("{e}");
+        Error::CreateAccountAddress.into()
+    })
 }
 
 #[derive(actix::Message)]
@@ -215,7 +218,6 @@ RETURNING id, name, email, phone, street, city, country, zip, account_id, is_def
 
 #[cfg(test)]
 mod test {
-    use actix::{Actor, Addr};
     use config::*;
     use fake::Fake;
     use model::*;
@@ -226,20 +228,22 @@ mod test {
 
     impl UpdateConfig for NoOpts {}
 
-    async fn test_create_account(db: Addr<Database>) -> FullAccount {
+    async fn test_create_account(pool: &mut sqlx::Transaction<'_, sqlx::Postgres>) -> FullAccount {
         let login: String = fake::faker::internet::en::Username().fake();
         let email: String = fake::faker::internet::en::FreeEmail().fake();
         let hash: String = fake::faker::internet::en::Password(10..20).fake();
 
-        db.send(CreateAccount {
+        crate::create_account(
+            CreateAccount {
                 email: Email::new(email),
                 login: Login::new(login),
                 pass_hash: PassHash::new(hash),
                 role: Role::Admin,
-        })
+            },
+            pool,
+        )
         .await
         .unwrap()
-        .unwrap()
     }
 
     #[actix::test]
@@ -250,10 +254,12 @@ mod test {
             .database_mut()
             .set_url("postgres://postgres@localhost/bazzar_test");
 
-        let db = Database::build(config).await.start();
+        let db = Database::build(config).await;
+        let pool = db.pool();
+        let mut t = pool.begin().await.unwrap();
 
         // account
-        let account = test_create_account(db.clone()).await;
+        let account = test_create_account(&mut t).await;
 
         // address
         let mut address: AccountAddress = {
@@ -265,35 +271,36 @@ mod test {
             let country: String = fake::faker::address::en::CountryName().fake();
             let zip: String = fake::faker::address::en::ZipCode().fake();
             let account_id = Some(account.id);
-            let is_default: bool = fake::faker::boolean::en::Boolean(6).fake();
+            let is_default: bool = true;
 
-            let address = db
+            let address = super::create_address(
-                .send(CreateAccountAddress {
+                CreateAccountAddress {
-                    name: model::Name::new(name.clone()),
+                    name: Name::new(name.clone()),
-                    email: model::Email::new(email.clone()),
+                    email: Email::new(email.clone()),
-                    phone: model::Phone::new(phone.clone()),
+                    phone: Phone::new(phone.clone()),
-                    street: model::Street::new(street.clone()),
+                    street: Street::new(street.clone()),
-                    city: model::City::new(city.clone()),
+                    city: City::new(city.clone()),
-                    country: model::Country::new(country.clone()),
+                    country: Country::new(country.clone()),
-                    zip: model::Zip::new(zip.clone()),
+                    zip: Zip::new(zip.clone()),
                     account_id: account_id.clone(),
-                    is_default: is_default.clone(),
+                    is_default,
-                })
+                },
+                &mut t,
+            )
             .await
-                .unwrap()
             .unwrap();
 
             assert_eq!(
                 address,
-                model::AccountAddress {
+                AccountAddress {
                     id: address.id,
-                    name: model::Name::new(name.clone()),
+                    name: Name::new(name.clone()),
-                    email: model::Email::new(email.clone()),
+                    email: Email::new(email.clone()),
-                    phone: model::Phone::new(phone.clone()),
+                    phone: Phone::new(phone.clone()),
-                    street: model::Street::new(street.clone()),
+                    street: Street::new(street.clone()),
-                    city: model::City::new(city.clone()),
+                    city: City::new(city.clone()),
-                    country: model::Country::new(country.clone()),
+                    country: Country::new(country.clone()),
-                    zip: model::Zip::new(zip.clone()),
+                    zip: Zip::new(zip.clone()),
                     account_id: account.id,
                     is_default,
                 }
@@ -301,19 +308,20 @@ mod test {
             address
         };
 
-        let found = db
+        let found = super::find_account_address(
-            .send(FindAccountAddress {
+            FindAccountAddress {
                 account_id: account.id,
                 address_id: address.id,
-            })
+            },
+            &mut t,
+        )
         .await
-            .unwrap()
         .unwrap();
 
         assert_eq!(found, address);
 
-        let changed = db
+        let changed = super::update_account_address(
-            .send(UpdateAccountAddress {
+            UpdateAccountAddress {
                 id: address.id,
                 name: address.name.clone(),
                 email: address.email.clone(),
@@ -324,23 +332,26 @@ mod test {
                 zip: address.zip.clone(),
                 account_id: address.account_id.clone(),
                 is_default: true,
-            })
+            },
+            &mut t,
+        )
         .await
-            .unwrap()
         .unwrap();
 
         address.is_default = true;
 
         assert_eq!(changed, address);
 
-        let default_address = db
+        let default_address = super::default_account_address(
-            .send(DefaultAccountAddress {
+            DefaultAccountAddress {
                 account_id: account.id,
-            })
+            },
+            &mut t,
+        )
         .await
-            .unwrap()
         .unwrap();
 
+        t.rollback().await.unwrap();
         assert_eq!(default_address, address);
     }
 }

actors/database_manager/src/accounts.rs

@@ -1,7 +1,6 @@
 #[cfg(feature = "dummy")]
 use fake::Fake;
-use model::{AccountId, AccountState, Email, FullAccount, Login, PassHash, Role};
+use model::*;
-use sqlx::PgPool;
 
 use crate::{db_async_handler, Result};
 
@@ -24,16 +23,24 @@ pub enum Error {
 #[rtype(result = "Result<Vec<FullAccount>>")]
 pub struct AllAccounts;
 
-db_async_handler!(AllAccounts, all_accounts, Vec<FullAccount>);
+db_async_handler!(
+    AllAccounts,
+    all_accounts,
+    Vec<FullAccount>,
+    inner_all_accounts
+);
 
-pub(crate) async fn all_accounts(_msg: AllAccounts, pool: PgPool) -> Result<Vec<FullAccount>> {
+pub(crate) async fn all_accounts(
+    _msg: AllAccounts,
+    pool: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+) -> Result<Vec<FullAccount>> {
     sqlx::query_as(
         r#"
 SELECT id, email, login, pass_hash, role, customer_id, state
 FROM accounts
     "#,
     )
-    .fetch_all(&pool)
+    .fetch_all(pool)
     .await
     .map_err(|e| {
         log::error!("{e:?}");
@@ -51,9 +58,17 @@ pub struct CreateAccount {
     pub role: Role,
 }
 
-db_async_handler!(CreateAccount, create_account, FullAccount);
+db_async_handler!(
+    CreateAccount,
+    create_account,
+    FullAccount,
+    inner_create_account
+);
 
-pub(crate) async fn create_account(msg: CreateAccount, db: PgPool) -> Result<FullAccount> {
+pub(crate) async fn create_account(
+    msg: CreateAccount,
+    pool: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+) -> Result<FullAccount> {
     sqlx::query_as(
         r#"
 INSERT INTO accounts (login, email, role, pass_hash)
@@ -65,7 +80,7 @@ RETURNING id, email, login, pass_hash, role, customer_id, state
     .bind(msg.email)
     .bind(msg.role)
     .bind(msg.pass_hash)
-    .fetch_one(&db)
+    .fetch_one(pool)
     .await
     .map_err(|e| {
         log::error!("{e:?}");
@@ -85,9 +100,17 @@ pub struct UpdateAccount {
     pub state: AccountState,
 }
 
-db_async_handler!(UpdateAccount, update_account, FullAccount);
+db_async_handler!(
+    UpdateAccount,
+    update_account,
+    FullAccount,
+    inner_update_account
+);
 
-pub(crate) async fn update_account(msg: UpdateAccount, db: PgPool) -> Result<FullAccount> {
+pub(crate) async fn update_account(
+    msg: UpdateAccount,
+    pool: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+) -> Result<FullAccount> {
     match msg.pass_hash {
         Some(hash) => sqlx::query_as(
             r#"
@@ -117,7 +140,7 @@ RETURNING id, email, login, pass_hash, role, customer_id, state
         .bind(msg.role)
         .bind(msg.state),
     }
-    .fetch_one(&db)
+    .fetch_one(pool)
     .await
     .map_err(|e| {
         log::error!("{e:?}");
@@ -131,9 +154,12 @@ pub struct FindAccount {
     pub account_id: AccountId,
 }
 
-db_async_handler!(FindAccount, find_account, FullAccount);
+db_async_handler!(FindAccount, find_account, FullAccount, inner_find_account);
 
-pub(crate) async fn find_account(msg: FindAccount, db: PgPool) -> Result<FullAccount> {
+pub(crate) async fn find_account(
+    msg: FindAccount,
+    pool: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+) -> Result<FullAccount> {
     sqlx::query_as(
         r#"
 SELECT id, email, login, pass_hash, role, customer_id, state
@@ -142,7 +168,7 @@ WHERE id = $1
     "#,
     )
     .bind(msg.account_id)
-    .fetch_one(&db)
+    .fetch_one(pool)
     .await
     .map_err(|e| {
         log::error!("{e:?}");
@@ -157,9 +183,17 @@ pub struct AccountByIdentity {
     pub email: Option<Email>,
 }
 
-db_async_handler!(AccountByIdentity, account_by_identity, FullAccount);
+db_async_handler!(
+    AccountByIdentity,
+    account_by_identity,
+    FullAccount,
+    inner_account_by_identity
+);
 
-pub(crate) async fn account_by_identity(msg: AccountByIdentity, db: PgPool) -> Result<FullAccount> {
+pub(crate) async fn account_by_identity(
+    msg: AccountByIdentity,
+    pool: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+) -> Result<FullAccount> {
     match (msg.login, msg.email) {
         (Some(login), None) => sqlx::query_as(
             r#"
@@ -188,7 +222,7 @@ WHERE login = $1 AND email = $2
         .bind(email),
         _ => return Err(super::Error::Account(Error::NoIdentity)),
     }
-    .fetch_one(&db)
+    .fetch_one(pool)
     .await
     .map_err(|e| {
         log::error!("{e:?}");
@@ -198,7 +232,6 @@ WHERE login = $1 AND email = $2
 
 #[cfg(test)]
 mod tests {
-    use actix::Addr;
     use config::UpdateConfig;
     use fake::Fake;
     use model::*;
@@ -210,7 +243,7 @@ mod tests {
     impl UpdateConfig for NoOpts {}
 
     async fn test_create_account(
-        db: Addr<Database>,
+        t: &mut sqlx::Transaction<'_, sqlx::Postgres>,
         login: Option<String>,
         email: Option<String>,
         hash: Option<String>,
@@ -220,15 +253,17 @@ mod tests {
         let email: String = email.unwrap_or_else(|| en::FreeEmail().fake());
         let hash: String = hash.unwrap_or_else(|| en::Password(10..20).fake());
 
-        db.send(CreateAccount {
+        super::create_account(
+            CreateAccount {
                 email: Email::new(email),
                 login: Login::new(login),
                 pass_hash: PassHash::new(hash),
                 role: Role::Admin,
-        })
+            },
+            t,
+        )
         .await
         .unwrap()
-        .unwrap()
     }
 
     #[actix::test]
@@ -239,21 +274,24 @@ mod tests {
             .database_mut()
             .set_url("postgres://postgres@localhost/bazzar_test");
 
-        let db = Database::build(config).await.start();
+        let db = Database::build(config).await;
+        let pool = db.pool();
+        let mut t = pool.begin().await.unwrap();
 
         let login: String = fake::faker::internet::en::Username().fake();
         let email: String = fake::faker::internet::en::FreeEmail().fake();
         let hash: String = fake::faker::internet::en::Password(10..20).fake();
 
-        let account: FullAccount = db
+        let account: FullAccount = super::create_account(
-            .send(CreateAccount {
+            CreateAccount {
                 email: Email::new(&email),
                 login: Login::new(&login),
                 pass_hash: PassHash::new(&hash),
                 role: Role::Admin,
-            })
+            },
+            &mut t,
+        )
         .await
-            .unwrap()
         .unwrap();
 
         let expected = FullAccount {
@@ -266,6 +304,7 @@ mod tests {
             state: AccountState::Active,
         };
 
+        t.rollback().await.unwrap();
         assert_eq!(account, expected);
     }
 
@@ -277,14 +316,17 @@ mod tests {
             .database_mut()
             .set_url("postgres://postgres@localhost/bazzar_test");
 
-        let db = Database::build(config).await.start();
+        let db = Database::build(config).await;
+        let pool = db.pool();
+        let mut t = pool.begin().await.unwrap();
 
-        test_create_account(db.clone(), None, None, None).await;
+        test_create_account(&mut t, None, None, None).await;
-        test_create_account(db.clone(), None, None, None).await;
+        test_create_account(&mut t, None, None, None).await;
-        test_create_account(db.clone(), None, None, None).await;
+        test_create_account(&mut t, None, None, None).await;
 
-        let v: Vec<FullAccount> = db.send(AllAccounts).await.unwrap().unwrap();
+        let v: Vec<FullAccount> = super::all_accounts(AllAccounts, &mut t).await.unwrap();
         assert!(v.len() >= 3);
+        t.rollback().await.unwrap();
     }
 
     #[actix::test]
@@ -295,14 +337,16 @@ mod tests {
             .database_mut()
             .set_url("postgres://postgres@localhost/bazzar_test");
 
-        let db = Database::build(config).await.start();
+        let db = Database::build(config).await;
+        let pool = db.pool();
+        let mut t = pool.begin().await.unwrap();
 
         let original_login: String = fake::faker::internet::en::Username().fake();
         let original_email: String = fake::faker::internet::en::FreeEmail().fake();
         let original_hash: String = fake::faker::internet::en::Password(10..20).fake();
 
         let original_account = test_create_account(
-            db.clone(),
+            &mut t,
             Some(original_login.clone()),
             Some(original_email.clone()),
             Some(original_hash.clone()),
@@ -312,17 +356,18 @@ mod tests {
         let updated_login: String = fake::faker::internet::en::Username().fake();
         let updated_email: String = fake::faker::internet::en::FreeEmail().fake();
 
-        let updated_account: FullAccount = db
+        let updated_account: FullAccount = super::update_account(
-            .send(UpdateAccount {
+            UpdateAccount {
                 id: original_account.id,
                 email: Email::new(updated_email.clone()),
                 login: Login::new(updated_login.clone()),
                 pass_hash: None,
                 role: Role::Admin,
                 state: AccountState::Active,
-            })
+            },
+            &mut t,
+        )
         .await
-            .unwrap()
         .unwrap();
 
         let expected = FullAccount {
@@ -335,6 +380,7 @@ mod tests {
             state: AccountState::Active,
         };
 
+        t.rollback().await.unwrap();
         assert_ne!(original_account, expected);
         assert_eq!(updated_account, expected);
     }
@@ -347,14 +393,16 @@ mod tests {
             .database_mut()
             .set_url("postgres://postgres@localhost/bazzar_test");
 
-        let db = Database::build(config).await.start();
+        let db = Database::build(config).await;
+        let pool = db.pool();
+        let mut t = pool.begin().await.unwrap();
 
         let original_login: String = fake::faker::internet::en::Username().fake();
         let original_email: String = fake::faker::internet::en::FreeEmail().fake();
         let original_hash: String = fake::faker::internet::en::Password(10..20).fake();
 
         let original_account = test_create_account(
-            db.clone(),
+            &mut t,
             Some(original_login.clone()),
             Some(original_email.clone()),
             Some(original_hash.clone()),
@@ -365,17 +413,18 @@ mod tests {
         let updated_email: String = fake::faker::internet::en::FreeEmail().fake();
         let updated_hash: String = fake::faker::internet::en::Password(10..20).fake();
 
-        let updated_account: FullAccount = db
+        let updated_account: FullAccount = super::update_account(
-            .send(UpdateAccount {
+            UpdateAccount {
                 id: original_account.id,
                 email: Email::new(updated_email.clone()),
                 login: Login::new(updated_login.clone()),
                 pass_hash: Some(PassHash::new(updated_hash.clone())),
                 role: Role::Admin,
                 state: AccountState::Active,
-            })
+            },
+            &mut t,
+        )
         .await
-            .unwrap()
         .unwrap();
 
         let expected = FullAccount {
@@ -388,6 +437,7 @@ mod tests {
             state: AccountState::Active,
         };
 
+        t.rollback().await.unwrap();
         assert_ne!(original_account, expected);
         assert_eq!(updated_account, expected);
     }
@@ -400,18 +450,22 @@ mod tests {
             .database_mut()
             .set_url("postgres://postgres@localhost/bazzar_test");
 
-        let db = Database::build(config).await.start();
+        let db = Database::build(config).await;
+        let pool = db.pool();
+        let mut t = pool.begin().await.unwrap();
 
-        let account = test_create_account(db.clone(), None, None, None).await;
+        let account = test_create_account(&mut t, None, None, None).await;
 
-        let res: FullAccount = db
+        let res: FullAccount = super::find_account(
-            .send(FindAccount {
+            FindAccount {
                 account_id: account.id,
-            })
+            },
+            &mut t,
+        )
         .await
-            .unwrap()
         .unwrap();
 
+        t.rollback().await.unwrap();
         assert_eq!(account, res);
     }
 
@@ -423,19 +477,23 @@ mod tests {
             .database_mut()
             .set_url("postgres://postgres@localhost/bazzar_test");
 
-        let db = Database::build(config).await.start();
+        let db = Database::build(config).await;
+        let pool = db.pool();
+        let mut t = pool.begin().await.unwrap();
 
-        let account = test_create_account(db.clone(), None, None, None).await;
+        let account = test_create_account(&mut t, None, None, None).await;
 
-        let res: FullAccount = db
+        let res: FullAccount = super::account_by_identity(
-            .send(AccountByIdentity {
+            AccountByIdentity {
                 email: Some(account.email.clone()),
                 login: None,
-            })
+            },
+            &mut t,
+        )
         .await
-            .unwrap()
         .unwrap();
 
+        t.rollback().await.unwrap();
         assert_eq!(account, res);
     }
 
@@ -447,19 +505,23 @@ mod tests {
             .database_mut()
             .set_url("postgres://postgres@localhost/bazzar_test");
 
-        let db = Database::build(config).await.start();
+        let db = Database::build(config).await;
+        let pool = db.pool();
+        let mut t = pool.begin().await.unwrap();
 
-        let account = test_create_account(db.clone(), None, None, None).await;
+        let account = test_create_account(&mut t, None, None, None).await;
 
-        let res: FullAccount = db
+        let res: FullAccount = super::account_by_identity(
-            .send(AccountByIdentity {
+            AccountByIdentity {
                 login: Some(account.login.clone()),
                 email: None,
-            })
+            },
+            &mut t,
+        )
         .await
-            .unwrap()
         .unwrap();
 
+        t.rollback().await.unwrap();
         assert_eq!(account, res);
     }
 }

actors/database_manager/src/products.rs

@@ -133,6 +133,7 @@ RETURNING id,
     .await
     .map_err(|e| {
         log::error!("{e:?}");
+        eprintln!("{e:?}");
         crate::Error::Product(Error::Create)
     })
 }

actors/database_manager/src/stocks.rs

@@ -1,6 +1,5 @@
 use actix::Message;
 use model::{ProductId, Quantity, QuantityUnit, Stock, StockId};
-use sqlx::PgPool;
 
 use crate::{MultiLoad, Result};
 
@@ -22,16 +21,19 @@ pub enum Error {
 #[rtype(result = "Result<Vec<model::Stock>>")]
 pub struct AllStocks;
 
-crate::db_async_handler!(AllStocks, all_stocks, Vec<Stock>);
+crate::db_async_handler!(AllStocks, all_stocks, Vec<Stock>, inner_all_stocks);
 
-async fn all_stocks(_msg: AllStocks, pool: PgPool) -> Result<Vec<model::Stock>> {
+async fn all_stocks(
+    _msg: AllStocks,
+    pool: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+) -> Result<Vec<Stock>> {
     sqlx::query_as(
         r#"
 SELECT id, product_id, quantity, quantity_unit
 FROM stocks
     "#,
     )
-    .fetch_all(&pool)
+    .fetch_all(pool)
     .await
     .map_err(|e| {
         log::error!("{e:?}");
@@ -47,9 +49,12 @@ pub struct CreateStock {
     pub quantity_unit: QuantityUnit,
 }
 
-crate::db_async_handler!(CreateStock, create_stock, Stock);
+crate::db_async_handler!(CreateStock, create_stock, Stock, inner_create_stock);
 
-async fn create_stock(msg: CreateStock, pool: PgPool) -> Result<model::Stock> {
+async fn create_stock(
+    msg: CreateStock,
+    pool: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+) -> Result<Stock> {
     sqlx::query_as(
         r#"
 INSERT INTO stocks (product_id, quantity, quantity_unit)
@@ -60,10 +65,11 @@ RETURNING id, product_id, quantity, quantity_unit
     .bind(msg.product_id)
     .bind(msg.quantity)
     .bind(msg.quantity_unit)
-    .fetch_one(&pool)
+    .fetch_one(pool)
     .await
     .map_err(|e| {
         log::error!("{e:?}");
+        eprintln!("{e:?}");
         crate::Error::Stock(Error::Create)
     })
 }
@@ -77,9 +83,12 @@ pub struct UpdateStock {
     pub quantity_unit: QuantityUnit,
 }
 
-crate::db_async_handler!(UpdateStock, update_stock, Stock);
+crate::db_async_handler!(UpdateStock, update_stock, Stock, inner_update_stock);
 
-async fn update_stock(msg: UpdateStock, pool: PgPool) -> Result<model::Stock> {
+async fn update_stock(
+    msg: UpdateStock,
+    pool: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+) -> Result<Stock> {
     sqlx::query_as(
         r#"
 UPDATE stocks
@@ -94,7 +103,7 @@ RETURNING id, product_id, quantity, quantity_unit
     .bind(msg.quantity)
     .bind(msg.quantity_unit)
     .bind(msg.id)
-    .fetch_one(&pool)
+    .fetch_one(pool)
     .await
     .map_err(|e| {
         log::error!("{e:?}");
@@ -108,9 +117,17 @@ pub struct DeleteStock {
     pub stock_id: StockId,
 }
 
-crate::db_async_handler!(DeleteStock, delete_stock, Option<model::Stock>);
+crate::db_async_handler!(
+    DeleteStock,
+    delete_stock,
+    Option<model::Stock>,
+    inner_delete_stock
+);
 
-async fn delete_stock(msg: DeleteStock, pool: PgPool) -> Result<Option<Stock>> {
+async fn delete_stock(
+    msg: DeleteStock,
+    pool: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+) -> Result<Option<Stock>> {
     sqlx::query_as(
         r#"
 DELETE FROM stocks
@@ -119,7 +136,7 @@ RETURNING id, product_id, quantity, quantity_unit
     "#,
     )
     .bind(msg.stock_id)
-    .fetch_optional(&pool)
+    .fetch_optional(pool)
     .await
     .map_err(|e| {
         log::error!("{e:?}");
@@ -143,7 +160,7 @@ crate::db_async_handler!(
 async fn product_stock(
     msg: ProductsStock,
     pool: &mut sqlx::Transaction<'_, sqlx::Postgres>,
-) -> Result<Vec<model::Stock>> {
+) -> Result<Vec<Stock>> {
     Ok(MultiLoad::new(
         pool,
         r#"
@@ -160,3 +177,102 @@ async fn product_stock(
     )
     .await?)
 }
+
+#[cfg(test)]
+mod tests {
+    use config::UpdateConfig;
+    use fake::faker::lorem::en as lorem;
+    use fake::Fake;
+    use model::*;
+    use uuid::Uuid;
+
+    pub struct NoOpts;
+
+    impl UpdateConfig for NoOpts {}
+
+    use crate::*;
+
+    async fn test_product(pool: &mut sqlx::Transaction<'_, sqlx::Postgres>) -> Product {
+        create_product(
+            CreateProduct {
+                name: ProductName::new(format!("db stocks test product {}", Uuid::new_v4())),
+                short_description: ProductShortDesc::new(lorem::Paragraph(1..2).fake::<String>()),
+                long_description: ProductLongDesc::new(lorem::Paragraph(4..5).fake::<String>()),
+                category: None,
+                price: Price::from_u32(12321),
+                deliver_days_flag: Days(vec![Day::Friday, Day::Sunday]),
+            },
+            pool,
+        )
+        .await
+        .unwrap()
+    }
+
+    async fn test_stock(
+        pool: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+        product_id: Option<ProductId>,
+        quantity: Option<Quantity>,
+        quantity_unit: Option<QuantityUnit>,
+    ) -> Stock {
+        let product_id = match product_id {
+            Some(id) => id,
+            _ => test_product(&mut *pool).await.id,
+        };
+        let quantity = quantity.unwrap_or_else(|| Quantity::from_u32(345));
+        let quantity_unit = quantity_unit.unwrap_or_else(|| QuantityUnit::Piece);
+
+        super::create_stock(
+            CreateStock {
+                product_id,
+                quantity_unit,
+                quantity,
+            },
+            &mut *pool,
+        )
+        .await
+        .unwrap()
+    }
+
+    #[actix::test]
+    async fn create_stock() {
+        let config = config::default_load(&mut NoOpts);
+        config
+            .lock()
+            .database_mut()
+            .set_url("postgres://postgres@localhost/bazzar_test");
+
+        let db = Database::build(config).await;
+        let pool = db.pool();
+        let mut t = pool.begin().await.unwrap();
+        test_stock(&mut t, None, None, None).await;
+        t.rollback().await.unwrap();
+    }
+
+    #[actix::test]
+    async fn products_stock() {
+        let config = config::default_load(&mut NoOpts);
+        config
+            .lock()
+            .database_mut()
+            .set_url("postgres://postgres@localhost/bazzar_test");
+
+        let db = Database::build(config).await;
+        let pool = db.pool();
+        let mut t = pool.begin().await.unwrap();
+
+        let first = test_stock(&mut t, None, None, None).await;
+        let second = test_stock(&mut t, None, None, None).await;
+
+        let stocks: Vec<Stock> = super::product_stock(
+            ProductsStock {
+                product_ids: vec![first.product_id, second.product_id],
+            },
+            &mut t,
+        )
+        .await
+        .unwrap();
+
+        t.rollback().await.unwrap();
+        assert_eq!(stocks, vec![first, second]);
+    }
+}

shared/model/src/lib.rs

@@ -172,7 +172,7 @@ impl Role {
 
 #[cfg_attr(feature = "dummy", derive(fake::Dummy))]
 #[cfg_attr(feature = "db", derive(sqlx::Type))]
-#[derive(Copy, Clone, Debug, Hash, Display, Deserialize, Serialize)]
+#[derive(Copy, Clone, Debug, PartialEq, Hash, Display, Deserialize, Serialize)]
 #[serde(rename_all = "snake_case")]
 pub enum QuantityUnit {
     #[cfg_attr(feature = "db", sqlx(rename = "g"))]
@@ -283,6 +283,12 @@ impl Default for Audience {
 #[serde(transparent)]
 pub struct Price(NonNegative);
 
+impl Price {
+    pub fn from_u32(price: u32) -> Self {
+        Self(NonNegative(price as i32))
+    }
+}
+
 impl ops::Mul<Quantity> for Price {
     type Output = Self;
 
@@ -294,7 +300,7 @@ impl ops::Mul<Quantity> for Price {
 #[cfg_attr(feature = "dummy", derive(fake::Dummy))]
 #[cfg_attr(feature = "db", derive(sqlx::Type))]
 #[cfg_attr(feature = "db", sqlx(transparent))]
-#[derive(Serialize, Deserialize, Default, Debug, Copy, Clone, Hash, Deref, From)]
+#[derive(Serialize, Deserialize, Default, Debug, PartialEq, Copy, Clone, Hash, Deref, From)]
 #[serde(transparent)]
 pub struct Quantity(NonNegative);
 
@@ -429,7 +435,7 @@ impl<'de> serde::Deserialize<'de> for Email {
 
 #[cfg_attr(feature = "db", derive(sqlx::Type))]
 #[cfg_attr(feature = "db", sqlx(transparent))]
-#[derive(Serialize, Default, Debug, Copy, Clone, Hash, Deref, Display)]
+#[derive(Serialize, Default, Debug, PartialEq, Copy, Clone, Hash, Deref, Display)]
 #[serde(transparent)]
 pub struct NonNegative(i32);
 
@@ -591,7 +597,7 @@ impl TryFrom<i32> for Day {
 #[cfg_attr(feature = "dummy", derive(fake::Dummy))]
 #[derive(Serialize, Deserialize, Hash, Debug)]
 #[serde(transparent)]
-pub struct Days(Vec<Day>);
+pub struct Days(pub Vec<Day>);
 
 impl ops::Deref for Days {
     type Target = Vec<Day>;
@@ -856,13 +862,13 @@ pub struct Product {
 #[cfg_attr(feature = "dummy", derive(fake::Dummy))]
 #[cfg_attr(feature = "db", derive(sqlx::Type))]
 #[cfg_attr(feature = "db", sqlx(transparent))]
-#[derive(Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[serde(transparent)]
 pub struct StockId(pub RecordId);
 
 #[cfg_attr(feature = "dummy", derive(fake::Dummy))]
 #[cfg_attr(feature = "db", derive(sqlx::FromRow))]
-#[derive(Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 pub struct Stock {
     pub id: StockId,
     pub product_id: ProductId,