feat: identiy.User test OwnerAddEmployeeToStore and RegisterUser

src/identity/application/services/owner_manage_store_employee_service.rs

@@ -210,7 +210,7 @@ mod tests {
     use super::*;
 
     impl OwnerManageStoreEmployeesService {
-        pub fn mock_service(
+        pub fn mock_service_add_employee_to_store(
             times: Option<usize>,
             cmd: OwnerAddEmployeeToStoreCommand,
         ) -> OwnerManageStoreEmployeesServiceObj {

src/identity/domain/aggregate.rs

@@ -209,4 +209,69 @@ mod tests {
         assert!(!u.email_verified());
         assert!(u.set_email_verified(true).deleted());
     }
+
+    use std::sync::Arc;
+
+    use cqrs_es::test::TestFramework;
+
+    use super::*;
+    use crate::identity::{
+        application::services::{
+            events::IdentityEvent,
+            owner_manage_store_employee_service::*,
+            register_user::{
+                command::RegisterUserCommand, events::UserRegisteredEvent,
+                service::RegisterUserService,
+            },
+            IdentityCommand, MockIdentityServicesInterface,
+        },
+        domain::{owner_add_employee_to_store_command::*, owner_added_employee_to_store_event::*},
+    };
+    use crate::tests::bdd::*;
+
+    type UserTestFramework = TestFramework<User>;
+
+    #[test]
+    fn test_user_aggregate_register_user() {
+        let cmd = RegisterUserCommand::get_command();
+        let expected = UserRegisteredEvent::get_event(&cmd);
+        let expected = IdentityEvent::UserRegistered(expected);
+
+        let mut services = MockIdentityServicesInterface::new();
+        services
+            .expect_register_user()
+            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .return_const(RegisterUserService::mock_service(
+                IS_CALLED_ONLY_ONCE,
+                cmd.clone(),
+            ));
+
+        UserTestFramework::with(Arc::new(services))
+            .given_no_previous_events()
+            .when(IdentityCommand::RegisterUser(cmd))
+            .then_expect_events(vec![expected]);
+    }
+
+    #[test]
+    fn test_user_aggregate_owner_added_employee_to_store() {
+        let cmd = OwnerAddEmployeeToStoreCommand::get_cmd();
+        let expected = OwnerAddedEmployeeToStoreEvent::get_event(&cmd);
+        let expected = IdentityEvent::OwnerAddedEmployeeToStore(expected);
+
+        let mut services = MockIdentityServicesInterface::new();
+        services
+            .expect_owner_manage_employee()
+            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .return_const(
+                OwnerManageStoreEmployeesService::mock_service_add_employee_to_store(
+                    IS_CALLED_ONLY_ONCE,
+                    cmd.clone(),
+                ),
+            );
+
+        UserTestFramework::with(Arc::new(services))
+            .given_no_previous_events()
+            .when(IdentityCommand::OwnerAddEmployeeToStore(cmd))
+            .then_expect_events(vec![expected]);
+    }
 }

src/identity/domain/employee_aggregate.rs

@@ -387,25 +387,4 @@ mod tests {
             .when(IdentityCommand::EmployeeExitOrganization(cmd))
             .then_expect_events(vec![expected]);
     }
-
-    #[test]
-    fn test_owner_added_employee_to_store() {
-        let cmd = OwnerAddEmployeeToStoreCommand::get_cmd();
-        let expected = OwnerAddedEmployeeToStoreEvent::get_event(&cmd);
-        let expected = IdentityEvent::OwnerAddedEmployeeToStore(expected);
-
-        //            let mut services = MockIdentityServicesInterface::new();
-        //            services
-        //                .expect_employee_accept_invite_service()
-        //                .times(IS_CALLED_ONLY_ONCE.unwrap())
-        //                .return_const(EmployeeAcceptInviteService::mock_service(
-        //                    IS_CALLED_ONLY_ONCE,
-        //                    cmd.clone(),
-        //                ));
-        //
-        //            EmployeeTestFramework::with(Arc::new(services))
-        //                .given_no_previous_events()
-        //                .when(IdentityCommand::EmployeeAcceptInvite(cmd))
-        //                .then_expect_events(vec![expected]);
-    }
 }