feat: user_view login and register_user testests

src/identity/adapters/output/db/postgres/user_id_exists.rs

@@ -32,13 +32,30 @@ impl UserIDExistsOutDBPort for DBOutPostgresAdapter {
 }
 
 #[cfg(test)]
-mod tests {
+pub mod tests {
     use super::*;
 
     use crate::utils::uuid::tests::UUID;
 
     use crate::identity::domain::aggregate::*;
 
+    pub async fn create_user(user: &User, user_id: Uuid, db: &DBOutPostgresAdapter) {
+        sqlx::query!(
+            "INSERT INTO user_query
+                (version, user_id, email, hashed_password, first_name, last_name)
+            VALUES ($1, $2, $3, $4, $5, $6);",
+            1,
+            user_id,
+            user.email(),
+            user.hashed_password(),
+            user.first_name(),
+            user.last_name(),
+        )
+        .execute(&db.pool)
+        .await
+        .unwrap();
+    }
+
     #[actix_rt::test]
     async fn test_postgres_user_id_exists() {
         let settings = crate::settings::tests::get_settings().await;
@@ -54,20 +71,21 @@ mod tests {
         // state doesn't exist
         assert!(!db.user_id_exists(&UUID).await.unwrap());
 
-        sqlx::query!(
+        create_user(&user, UUID, &db).await;
-            "INSERT INTO user_query
+        //        sqlx::query!(
-                (version, user_id, email, hashed_password, first_name, last_name)
+        //            "INSERT INTO user_query
-            VALUES ($1, $2, $3, $4, $5, $6);",
+        //                (version, user_id, email, hashed_password, first_name, last_name)
-            1,
+        //            VALUES ($1, $2, $3, $4, $5, $6);",
-            UUID,
+        //            1,
-            user.email(),
+        //            UUID,
-            user.hashed_password(),
+        //            user.email(),
-            user.first_name(),
+        //            user.hashed_password(),
-            user.last_name(),
+        //            user.first_name(),
-        )
+        //            user.last_name(),
-        .execute(&db.pool)
+        //        )
-        .await
+        //        .execute(&db.pool)
-        .unwrap();
+        //        .await
+        //        .unwrap();
 
         // state exists
         assert!(db.user_id_exists(&UUID).await.unwrap());

src/identity/adapters/output/db/postgres/user_view.rs

@@ -14,7 +14,7 @@ use super::errors::*;
 use super::DBOutPostgresAdapter;
 use crate::identity::adapters::types::{IdentityUserCqrsExec, IdentityUserCqrsView};
 use crate::identity::application::services::{events::IdentityEvent, IdentityServicesObj};
-use crate::identity::domain::aggregate::User;
+use crate::identity::domain::aggregate::{User, UserBuilder};
 use crate::utils::parse_aggregate_id::parse_aggregate_id;
 
 pub const NEW_USER_NON_UUID: &str = "new_user_non_uuid-asdfa";
@@ -33,6 +33,23 @@ pub struct UserView {
     deleted: bool,
 }
 
+impl From<UserView> for User {
+    fn from(v: UserView) -> Self {
+        UserBuilder::default()
+            .first_name(v.first_name)
+            .last_name(v.last_name)
+            .user_id(v.user_id)
+            .email(v.email)
+            .hashed_password(v.hashed_password)
+            .is_admin(v.is_admin)
+            .is_verified(v.is_verified)
+            .deleted(v.deleted)
+            .email_verified(v.is_verified)
+            .build()
+            .unwrap()
+    }
+}
+
 // This updates the view with events as they are committed.
 // The logic should be minimal here, e.g., don't calculate the account balance,
 // design the events to carry the balance information instead.
@@ -241,3 +258,221 @@ pub fn init_cqrs(
         Arc::new(db.clone()),
     )
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use postgres_es::PostgresCqrs;
+
+    use crate::{
+        db::migrate::*,
+        identity::{
+            adapters::output::db::postgres::user_id_exists::tests::create_user,
+            application::{
+                port::output::mailer::account_validation_link::mock_account_validation_link_mailer_port,
+                services::{
+                    add_store_service::*,
+                    events::*,
+                    login::{command::*, service::*, *},
+                    register_user::{
+                        command::{tests::PASSWORD, *},
+                        events::*,
+                        service::*,
+                        *,
+                    },
+                    update_store_service::*,
+                    MockIdentityServicesInterface, *,
+                },
+            },
+            domain::{add_store_command::*, update_store_command::*},
+        },
+        settings::Settings,
+        tests::bdd::*,
+        utils::{random_number::*, random_string::*, uuid::tests::UUID, uuid::*},
+    };
+    use std::sync::Arc;
+
+    async fn init_test_context() -> (
+        Settings,
+        DBOutPostgresAdapter,
+        Vec<Box<dyn Query<User>>>,
+        MockIdentityServicesInterface,
+        GetUUIDInterfaceObj,
+        GenerateRandomStringInterfaceObj,
+        GenerateRandomNumberInterfaceObj,
+    ) {
+        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 = DBOutPostgresAdapter::new(db.pool.clone());
+
+        let simple_query = SimpleLoggingQuery {};
+
+        let queries: Vec<Box<dyn Query<User>>> = vec![Box::new(simple_query), Box::new(db.clone())];
+
+        let mut mock_services = MockIdentityServicesInterface::new();
+        let random_uuid = Arc::new(GenerateUUID);
+        let random_string = GenerateRandomString::new();
+        let random_number = GenerateRandomNumber::new();
+        (
+            settings,
+            db,
+            queries,
+            mock_services,
+            random_uuid,
+            random_string,
+            random_number,
+        )
+    }
+
+    #[actix_rt::test]
+    async fn user_view_login() {
+        let (settings, db, queries, mut mock_services, random_uuid, random_string, random_number) =
+            init_test_context().await;
+        let db2 = db.clone();
+        mock_services
+            .expect_login()
+            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .returning(move || Arc::new(LoginService));
+        let (cqrs_executor, cqrs_view) = init_cqrs(db.clone(), Arc::new(mock_services));
+
+        let user = User::default();
+        create_user(&user, *user.user_id(), &db).await;
+
+        let cmd = LoginCommand::get_cmd();
+        cqrs_executor
+            .execute(&user.user_id().to_string(), IdentityCommand::Login(cmd))
+            .await
+            .unwrap();
+
+        settings.drop_db().await;
+    }
+
+    #[actix_rt::test]
+    async fn user_view_register() {
+        let (settings, db, queries, mut mock_services, random_uuid, random_string, random_number) =
+            init_test_context().await;
+        let service: RegisterUserServiceObj = Arc::new(
+            RegisterUserServiceBuilder::default()
+                .db_email_exists_adapter(Arc::new(db.clone()))
+                .db_user_id_exists_adapter(Arc::new(db.clone()))
+                .db_create_verification_secret_adapter(Arc::new(db.clone()))
+                .mailer_account_validation_link_adapter(mock_account_validation_link_mailer_port(
+                    IGNORE_CALL_COUNT,
+                ))
+                .random_string_adapter(random_string.clone())
+                .build()
+                .unwrap(),
+        );
+
+        mock_services
+            .expect_register_user()
+            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .return_const(service); //(move || Arc::new(service.clone()));
+        let (cqrs_executor, cqrs_view) = init_cqrs(db.clone(), Arc::new(mock_services));
+
+        let cmd = RegisterUserCommand::get_command();
+        let user_id = *cmd.user_id();
+        cqrs_executor
+            .execute(
+                &user_id.to_string(),
+                IdentityCommand::RegisterUser(cmd.clone()),
+            )
+            .await
+            .unwrap();
+        let user = cqrs_view.load(&user_id.to_string()).await.unwrap().unwrap();
+        let user: User = user.into();
+
+        assert_eq!(user.first_name(), cmd.first_name());
+        assert_eq!(user.last_name(), cmd.last_name());
+        assert_eq!(user.email(), cmd.email());
+        assert_eq!(user.user_id(), cmd.user_id());
+        assert_eq!(user.hashed_password(), cmd.hashed_password());
+        assert!(!user.deleted());
+
+        settings.drop_db().await;
+    }
+
+    //        let cmd = AddStoreCommandBuilder::default()
+    //            .name(rand.get_random(10))
+    //            .address(None)
+    //            .owner(UUID)
+    //            .store_id(UUID)
+    //            .build()
+    //            .unwrap();
+    //        cqrs.execute(
+    //            &cmd.store_id().to_string(),
+    //            IdentityCommand::AddStore(cmd.clone()),
+    //        )
+    //
+    //
+    //        let (cqrs, store_query): (
+    //            Arc<PostgresCqrs<Store>>,
+    //            Arc<dyn ViewRepository<StoreView, Store>>,
+    //        ) = (
+    //            Arc::new(postgres_es::postgres_cqrs(
+    //                db.pool.clone(),
+    //                queries,
+    //                Arc::new(mock_services),
+    //            )),
+    //            Arc::new(db.clone()),
+    //        );
+    //
+    //        let cmd = AddStoreCommandBuilder::default()
+    //            .name(rand.get_random(10))
+    //            .address(None)
+    //            .owner(UUID)
+    //            .store_id(UUID)
+    //            .build()
+    //            .unwrap();
+    //        cqrs.execute(
+    //            &cmd.store_id().to_string(),
+    //            IdentityCommand::AddStore(cmd.clone()),
+    //        )
+    //        .await
+    //        .unwrap();
+    //
+    //        let store = store_query
+    //            .load(&(*cmd.store_id()).to_string())
+    //            .await
+    //            .unwrap()
+    //            .unwrap();
+    //        let store: Store = store.into();
+    //        assert_eq!(store.name(), cmd.name());
+    //        assert_eq!(store.address(), cmd.address());
+    //        assert_eq!(store.owner(), cmd.owner());
+    //        assert_eq!(store.store_id(), cmd.store_id());
+    //        assert!(!store.deleted());
+    //
+    //        let update_store_cmd = UpdateStoreCommand::new(
+    //            rand.get_random(10),
+    //            Some(rand.get_random(10)),
+    //            UUID,
+    //            store,
+    //            UUID,
+    //        )
+    //        .unwrap();
+    //        cqrs.execute(
+    //            &cmd.store_id().to_string(),
+    //            IdentityCommand::UpdateStore(update_store_cmd.clone()),
+    //        )
+    //        .await
+    //        .unwrap();
+    //        let store = store_query
+    //            .load(&(*cmd.store_id()).to_string())
+    //            .await
+    //            .unwrap()
+    //            .unwrap();
+    //        let store: Store = store.into();
+    //        assert_eq!(store.name(), update_store_cmd.name());
+    //        assert_eq!(store.address(), update_store_cmd.address());
+    //        assert_eq!(store.owner(), update_store_cmd.owner());
+    //        assert_eq!(store.store_id(), update_store_cmd.old_store().store_id());
+    //        assert!(!store.deleted());
+    //
+    //        settings.drop_db().await;
+}