feat: inventory: customization view tests

src/inventory/adapters/output/db/postgres/customization_view.rs

@@ -187,12 +187,10 @@ impl ViewRepository<CustomizationView, Customization> for InventoryDBPostgresAda
                     SET
                         version = $1,
                         name = $2,
-                        customization_id = $3,
-                        product_id = $4,
-                        deleted = $5;",
+                        product_id = $3,
+                        deleted = $4;",
                     version,
                     view.name,
-                    view.customization_id,
                     view.product_id,
                     view.deleted,
                 )
@@ -225,3 +223,145 @@ impl Query<Customization> for InventoryDBPostgresAdapter {
         self.update_view(view, view_context).await.unwrap();
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use postgres_es::PostgresCqrs;
+
+    use crate::{
+        db::migrate::*,
+        inventory::{
+            adapters::output::db::postgres::product_id_exists::tests::create_dummy_product_record,
+            application::services::{
+                add_customization_service::*, update_customization_service::*,
+                MockInventoryServicesInterface,
+            },
+            domain::{
+                add_customization_command::*,
+                commands::InventoryCommand,
+                product_aggregate::Product,
+                update_customization_command::{tests::get_update_customization_command, *},
+            },
+        },
+        tests::bdd::*,
+        utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
+    };
+    use std::sync::Arc;
+
+    #[actix_rt::test]
+    async fn pg_query_inventory_customization_view() {
+        let settings = crate::settings::tests::get_settings().await;
+        //let settings = crate::settings::Settings::new().unwrap();
+        settings.create_db().await;
+
+        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
+        db.migrate().await;
+        let db = InventoryDBPostgresAdapter::new(db.pool.clone());
+        let product = Product::default();
+        create_dummy_product_record(&product, &db).await;
+
+        //        let simple_query = super::store_view::SimpleLoggingQuery {};
+
+        let queries: Vec<Box<dyn Query<Customization>>> = vec![Box::new(db.clone())];
+
+        let mut mock_services = MockInventoryServicesInterface::new();
+
+        let db2 = db.clone();
+        mock_services
+            .expect_add_customization()
+            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .returning(move || {
+                Arc::new(
+                    AddCustomizationServiceBuilder::default()
+                        .db_product_id_exists(Arc::new(db2.clone()))
+                        .db_customization_id_exists(Arc::new(db2.clone()))
+                        .db_customization_name_exists_for_product(Arc::new(db2.clone()))
+                        .build()
+                        .unwrap(),
+                )
+            });
+
+        let db2 = Arc::new(db.clone());
+        mock_services
+            .expect_update_customization()
+            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .returning(move || {
+                Arc::new(
+                    UpdateCustomizationServiceBuilder::default()
+                        .db_product_id_exists(db2.clone())
+                        .db_customization_name_exists_for_product(db2.clone())
+                        .db_customization_id_exists(db2.clone())
+                        .build()
+                        .unwrap(),
+                )
+            });
+
+        let (cqrs, custmoization_query): (
+            Arc<PostgresCqrs<Customization>>,
+            Arc<dyn ViewRepository<CustomizationView, Customization>>,
+        ) = (
+            Arc::new(postgres_es::postgres_cqrs(
+                db.pool.clone(),
+                queries,
+                Arc::new(mock_services),
+            )),
+            Arc::new(db.clone()),
+        );
+
+        let rand = crate::utils::random_string::GenerateRandomString {};
+
+        let cmd = AddCustomizationCommandBuilder::default()
+            .name(rand.get_random(10))
+            .product_id(product.product_id().clone())
+            .customization_id(UUID.clone())
+            .build()
+            .unwrap();
+
+        cqrs.execute(
+            &cmd.customization_id().to_string(),
+            InventoryCommand::AddCustomization(cmd.clone()),
+        )
+        .await
+        .unwrap();
+        let customization = custmoization_query
+            .load(&(*cmd.customization_id()).to_string())
+            .await
+            .unwrap()
+            .unwrap();
+        let customization: Customization = customization.into();
+        assert_eq!(customization.name(), cmd.name());
+        assert_eq!(customization.customization_id(), cmd.customization_id());
+        assert_eq!(customization.product_id(), cmd.product_id());
+        assert!(!customization.deleted());
+
+        let update_customization_command = UnvalidatedUpdateCustomizationCommandBuilder::default()
+            .name(rand.get_random(10))
+            .old_customization(customization.clone())
+            .adding_by(UUID.clone())
+            .build()
+            .unwrap()
+            .validate()
+            .unwrap();
+        cqrs.execute(
+            &cmd.customization_id().to_string(),
+            InventoryCommand::UpdateCustomization(update_customization_command.clone()),
+        )
+        .await
+        .unwrap();
+        let c = custmoization_query
+            .load(&(*cmd.customization_id()).to_string())
+            .await
+            .unwrap()
+            .unwrap();
+        let c: Customization = c.into();
+        assert_eq!(c.name(), update_customization_command.name());
+        assert_eq!(
+            update_customization_command.old_customization(),
+            &customization
+        );
+        assert!(!c.deleted());
+        settings.drop_db().await;
+    }
+}

src/inventory/adapters/output/db/postgres/product_id_exists.rs

@@ -95,8 +95,8 @@ pub mod tests {
                 );",
             1,
             p.name(),
-            p.description().as_ref().unwrap(),
-            p.image().as_ref().unwrap(),
+            p.description().as_ref().map(|s| s.as_str()),
+            p.image().as_ref().map(|s| s.as_str()),
             p.product_id(),
             p.category_id(),
             p.price().major().clone() as i32,

src/inventory/adapters/output/db/postgres/store_view.rs

@@ -225,7 +225,6 @@ impl Query<Store> for InventoryDBPostgresAdapter {
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/inventory/application/services/add_customization_service.rs

@@ -24,7 +24,6 @@ use crate::inventory::{
         product_aggregate::*,
     },
 };
-use crate::utils::uuid::*;
 
 #[automock]
 #[async_trait::async_trait]
@@ -42,7 +41,6 @@ pub struct AddCustomizationService {
     db_product_id_exists: ProductIDExistsDBPortObj,
     db_customization_id_exists: CustomizationIDExistsDBPortObj,
     db_customization_name_exists_for_product: CustomizationNameExistsForProductDBPortObj,
-    get_uuid: GetUUIDInterfaceObj,
 }
 
 #[async_trait::async_trait]
@@ -59,25 +57,19 @@ impl AddCustomizationUseCase for AddCustomizationService {
             return Err(InventoryError::ProductIDNotFound);
         }
 
-        let mut customization_id = self.get_uuid.get_uuid();
-        loop {
         if self
             .db_customization_id_exists
-                .customization_id_exists(&customization_id)
+            .customization_id_exists(cmd.customization_id())
             .await?
         {
-                customization_id = self.get_uuid.get_uuid();
-                continue;
-            } else {
-                break;
-            }
+            return Err(InventoryError::DuplicateCustomizationID);
         }
 
         let customization = CustomizationBuilder::default()
             .name(cmd.name().into())
             .deleted(false)
             .product_id(*cmd.product_id())
-            .customization_id(customization_id)
+            .customization_id(*cmd.customization_id())
             .build()
             .unwrap();
 
@@ -101,11 +93,9 @@ pub mod tests {
     use super::*;
 
     use customization_added_event::tests::get_customization_added_event_from_cmd;
-    use uuid::Uuid;
 
     use crate::inventory::domain::add_customization_command::tests::get_command;
-    use crate::utils::uuid::tests::UUID;
-    use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
+    use crate::tests::bdd::*;
 
     pub fn mock_add_customization_service(
         times: Option<usize>,
@@ -138,12 +128,16 @@ pub mod tests {
             .db_customization_name_exists_for_product(
                 mock_customization_name_exists_for_product_db_port_false(IS_CALLED_ONLY_ONCE),
             )
-            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
         let res = s.add_customization(cmd.clone()).await.unwrap();
         assert_eq!(res.customization().name(), cmd.name());
+        assert_eq!(res.customization().product_id(), cmd.product_id());
+        assert_eq!(
+            res.customization().customization_id(),
+            cmd.customization_id()
+        );
         //        assert_eq!(customization_added_events.len(), cmd.customizations().len());
     }
 
@@ -159,7 +153,6 @@ pub mod tests {
             .db_customization_name_exists_for_product(
                 mock_customization_name_exists_for_product_db_port_true(IS_CALLED_ONLY_ONCE),
             )
-            .get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
             .build()
             .unwrap();
 
@@ -179,7 +172,6 @@ pub mod tests {
             .db_customization_name_exists_for_product(
                 mock_customization_name_exists_for_product_db_port_false(IS_NEVER_CALLED),
             )
-            .get_uuid(mock_get_uuid(IS_NEVER_CALLED))
             .build()
             .unwrap();
 

src/inventory/application/services/errors.rs

@@ -18,6 +18,7 @@ pub enum InventoryError {
     DuplicateStoreName,
     DuplicateProductName,
     DuplicateCustomizationName,
+    DuplicateCustomizationID,
     DuplicateStoreID,
     ProductIDNotFound,
     CategoryIDNotFound,
@@ -42,10 +43,7 @@ impl From<InventoryDBError> for InventoryError {
                 error!("DuplicateCategoryID");
                 Self::InternalError
             }
-            InventoryDBError::DuplicateCustomizationID => {
-                error!("DuplicateCustomizationID");
-                Self::InternalError
-            }
+            InventoryDBError::DuplicateCustomizationID => Self::DuplicateCustomizationID,
             InventoryDBError::InternalError => Self::InternalError,
             InventoryDBError::ProductIDNotFound => InventoryError::ProductIDNotFound,
             InventoryDBError::CategoryIDNotFound => InventoryError::CategoryIDNotFound,

src/inventory/domain/add_customization_command.rs

@@ -16,28 +16,26 @@ pub enum AddCustomizationCommandError {
 #[derive(
     Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
 )]
-pub struct UnvalidatedAddCustomizationCommand {
-    name: String,
-    product_id: Uuid,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
+#[builder(build_fn(validate = "Self::validate"))]
 pub struct AddCustomizationCommand {
+    #[builder(setter(custom))]
     name: String,
     product_id: Uuid,
+    customization_id: Uuid,
 }
 
-impl UnvalidatedAddCustomizationCommand {
-    pub fn validate(self) -> Result<AddCustomizationCommand, AddCustomizationCommandError> {
-        let name = self.name.trim().to_owned();
-        if name.is_empty() {
-            return Err(AddCustomizationCommandError::NameIsEmpty);
+impl AddCustomizationCommandBuilder {
+    pub fn name(&mut self, name: String) -> &mut Self {
+        self.name = Some(name.trim().to_owned());
+        self
     }
 
-        Ok(AddCustomizationCommand {
-            name,
-            product_id: self.product_id,
-        })
+    fn validate(&self) -> Result<(), String> {
+        let name = self.name.as_ref().unwrap().trim().to_owned();
+        if name.is_empty() {
+            return Err(AddCustomizationCommandError::NameIsEmpty.to_string());
+        }
+        Ok(())
     }
 }
 
@@ -48,13 +46,12 @@ pub mod tests {
     use crate::utils::uuid::tests::UUID;
 
     pub fn get_command() -> AddCustomizationCommand {
-        UnvalidatedAddCustomizationCommandBuilder::default()
+        AddCustomizationCommandBuilder::default()
             .name("foo".into())
             .product_id(UUID.clone())
+            .customization_id(UUID.clone())
             .build()
             .unwrap()
-            .validate()
-            .unwrap()
     }
 
     #[test]
@@ -62,12 +59,11 @@ pub mod tests {
         let name = "foo";
         let product_id = UUID;
 
-        let cmd = UnvalidatedAddCustomizationCommandBuilder::default()
+        let cmd = AddCustomizationCommandBuilder::default()
             .name(name.into())
             .product_id(product_id.clone())
+            .customization_id(UUID.clone())
             .build()
-            .unwrap()
-            .validate()
             .unwrap();
 
         assert_eq!(cmd.name(), name);
@@ -78,14 +74,11 @@ pub mod tests {
     fn test_cmd_name_is_empty() {
         let product_id = UUID;
 
-        assert_eq!(
-            UnvalidatedAddCustomizationCommandBuilder::default()
+        assert!(AddCustomizationCommandBuilder::default()
             .name("".into())
             .product_id(product_id.clone())
+            .customization_id(UUID.clone())
             .build()
-                .unwrap()
-                .validate(),
-            Err(AddCustomizationCommandError::NameIsEmpty)
-        );
+            .is_err(),);
     }
 }

src/inventory/domain/add_store_command.rs

@@ -27,8 +27,6 @@ pub struct AddStoreCommand {
 }
 
 impl AddStoreCommandBuilder {
-    //    pub fn custom_address(&mut self, address: Option<String>) -> &mut Self {
-    //    fn address(&mut self, address: Option<String>) {
     pub fn address(&mut self, address: Option<String>) -> &mut Self {
         self.address = if let Some(address) = address {
             let address = address.trim();
@@ -43,8 +41,6 @@ impl AddStoreCommandBuilder {
         self
     }
 
-    //pub fn custom_name(&mut self, name: String) -> &mut Self {
-    //fn name(&mut self, name: String) {
     pub fn name(&mut self, name: String) -> &mut Self {
         self.name = Some(name.trim().to_owned());
         self