diff --git a/src/identity/application/services/employee_accept_invite_service.rs b/src/identity/application/services/employee_accept_invite_service.rs index 1452d50..f4fef1d 100644 --- a/src/identity/application/services/employee_accept_invite_service.rs +++ b/src/identity/application/services/employee_accept_invite_service.rs @@ -2,12 +2,15 @@ // // SPDX-License-Identifier: AGPL-3.0-or-later use derive_builder::Builder; +use mockall::predicate::*; +use mockall::*; use crate::identity::application::port::output::db::{emp_id_exists::*, get_invite::*}; use crate::identity::domain::{accept_invite_command::*, invite_accepted_event::*}; use super::errors::*; +#[automock] #[async_trait::async_trait] pub trait EmployeeAcceptInviteUseCase: Send + Sync { async fn accept_invite(&self, cmd: AcceptInviteCommand) -> IdentityResult; @@ -60,6 +63,26 @@ mod tests { use super::*; + impl EmployeeAcceptInviteService { + pub fn mock_service( + times: Option, + cmd: AcceptInviteCommand, + ) -> EmployeeAcceptInviteServiceObj { + let res = InviteAcceptedEvent::get_event(&cmd); + let mut m = MockEmployeeAcceptInviteUseCase::default(); + + if let Some(times) = times { + m.expect_accept_invite() + .times(times) + .returning(move |_| Ok(res.clone())); + } else { + m.expect_accept_invite().returning(move |_| Ok(res.clone())); + } + + std::sync::Arc::new(m) + } + } + #[actix_rt::test] async fn test_service() { let s = EmployeeAcceptInviteServiceBuilder::default() diff --git a/src/identity/application/services/employee_exit_organization_service.rs b/src/identity/application/services/employee_exit_organization_service.rs index 438ca83..1649cb9 100644 --- a/src/identity/application/services/employee_exit_organization_service.rs +++ b/src/identity/application/services/employee_exit_organization_service.rs @@ -2,12 +2,15 @@ // // SPDX-License-Identifier: AGPL-3.0-or-later use derive_builder::Builder; +use mockall::predicate::*; +use mockall::*; use crate::identity::application::port::output::db::{emp_id_exists::*, store_id_exists::*}; use crate::identity::domain::{exit_organization_command::*, organization_exited_event::*}; use super::errors::*; +#[automock] #[async_trait::async_trait] pub trait EmployeeExitOrganizationUseCase: Send + Sync { async fn exit_organization( @@ -60,6 +63,27 @@ mod tests { use super::*; + impl EmployeeExitOrganizationService { + pub fn mock_service( + times: Option, + cmd: ExitOrganizationCommand, + ) -> EmployeeExitOrganizationServiceObj { + let res = OrganizationExitedEvent::get_event(&cmd); + let mut m = MockEmployeeExitOrganizationUseCase::default(); + + if let Some(times) = times { + m.expect_exit_organization() + .times(times) + .returning(move |_| Ok(res.clone())); + } else { + m.expect_exit_organization() + .returning(move |_| Ok(res.clone())); + } + + std::sync::Arc::new(m) + } + } + #[actix_rt::test] async fn test_service() { let s = EmployeeExitOrganizationServiceBuilder::default() diff --git a/src/identity/application/services/employee_login_service.rs b/src/identity/application/services/employee_login_service.rs index 58f990e..9dbf518 100644 --- a/src/identity/application/services/employee_login_service.rs +++ b/src/identity/application/services/employee_login_service.rs @@ -236,7 +236,7 @@ mod tests { let s = EmployeeLoginServiceBuilder::default() .db_phone_exists_adapter(mock_phone_exists_db_port(IS_CALLED_ONLY_ONCE, true)) .db_get_emp_id_from_phone_number_adapter(mock_get_emp_id_from_phone_number_db_port( - IS_NEVER_CALLED, + IS_CALLED_ONLY_ONCE, )) .db_create_login_otp_adapter(mock_create_login_otp_db_port(IS_NEVER_CALLED)) .db_delete_login_otp(mock_delete_login_otp_db_port(IS_NEVER_CALLED)) diff --git a/src/identity/application/services/employee_resend_login_otp_service.rs b/src/identity/application/services/employee_resend_login_otp_service.rs index 7fca493..94676c5 100644 --- a/src/identity/application/services/employee_resend_login_otp_service.rs +++ b/src/identity/application/services/employee_resend_login_otp_service.rs @@ -2,6 +2,8 @@ // // SPDX-License-Identifier: AGPL-3.0-or-later use derive_builder::Builder; +use mockall::predicate::*; +use mockall::*; use crate::identity::application::port::output::{ db::{ @@ -18,6 +20,7 @@ use crate::utils::random_number::*; use super::employee_register_service::OTP_LEN; use super::errors::*; +#[automock] #[async_trait::async_trait] pub trait EmployeeResendLoginOTPUseCase: Send + Sync { async fn resend_otp(&self, cmd: ResendLoginOTPCommand) -> IdentityResult; @@ -79,6 +82,26 @@ mod tests { use super::*; + impl EmployeeResendLoginOTPService { + pub fn mock_service( + times: Option, + _cmd: ResendLoginOTPCommand, + ) -> EmployeeResendLoginOTPServiceObj { + let res = ResentLoginOTPEvent::get_event(); + let mut m = MockEmployeeResendLoginOTPUseCase::default(); + + if let Some(times) = times { + m.expect_resend_otp() + .times(times) + .returning(move |_| Ok(res.clone())); + } else { + m.expect_resend_otp().returning(move |_| Ok(res.clone())); + } + + std::sync::Arc::new(m) + } + } + #[actix_rt::test] async fn test_service_init_login() { let s = EmployeeResendLoginOTPServiceBuilder::default() diff --git a/src/identity/application/services/employee_resend_verification_otp_service.rs b/src/identity/application/services/employee_resend_verification_otp_service.rs index e99f8fb..c7615d6 100644 --- a/src/identity/application/services/employee_resend_verification_otp_service.rs +++ b/src/identity/application/services/employee_resend_verification_otp_service.rs @@ -2,6 +2,8 @@ // // SPDX-License-Identifier: AGPL-3.0-or-later use derive_builder::Builder; +use mockall::predicate::*; +use mockall::*; use super::errors::*; use crate::identity::domain::resend_verification_otp_command::*; @@ -13,6 +15,7 @@ use crate::identity::{ domain::verification_otp_resent_event::*, }; +#[automock] #[async_trait::async_trait] pub trait EmployeeResendVerificationOTPUseCase: Send + Sync { async fn resend_otp( @@ -74,10 +77,34 @@ impl EmployeeResendVerificationOTPUseCase for EmployeeResendVerificationOTPServi #[cfg(test)] mod tests { - use crate::{identity::domain::employee_aggregate::*, tests::bdd::*, utils::uuid::tests::*}; + use crate::{ + identity::{application::services::ResendLoginOTPCommand, domain::employee_aggregate::*}, + tests::bdd::*, + utils::uuid::tests::*, + }; use super::*; + impl EmployeeResendVerificationOTPService { + pub fn mock_service( + times: Option, + _cmd: ResendVerificationOTPCommand, + ) -> EmployeeResendVerificationOTPServiceObj { + let res = VerificationOTPResentEvent::get_event(); + let mut m = MockEmployeeResendVerificationOTPUseCase::default(); + + if let Some(times) = times { + m.expect_resend_otp() + .times(times) + .returning(move |_| Ok(res.clone())); + } else { + m.expect_resend_otp().returning(move |_| Ok(res.clone())); + } + + std::sync::Arc::new(m) + } + } + #[actix_rt::test] async fn test_service_init_login() { let s = EmployeeResendVerificationOTPServiceBuilder::default() diff --git a/src/identity/application/services/employee_verify_phone_number_service.rs b/src/identity/application/services/employee_verify_phone_number_service.rs index b4c92fa..f8038d9 100644 --- a/src/identity/application/services/employee_verify_phone_number_service.rs +++ b/src/identity/application/services/employee_verify_phone_number_service.rs @@ -2,6 +2,8 @@ // // SPDX-License-Identifier: AGPL-3.0-or-later use derive_builder::Builder; +use mockall::predicate::*; +use mockall::*; use crate::identity::application::port::output::db::{ delete_verification_otp::*, get_emp_id_from_phone_number::*, get_verification_otp::*, @@ -10,6 +12,7 @@ use crate::identity::domain::{phone_number_verified_event::*, verify_phone_numbe use super::errors::*; +#[automock] #[async_trait::async_trait] pub trait EmployeeVerifyPhoneNumberUseCase: Send + Sync { async fn verify_phone_number( @@ -67,6 +70,27 @@ mod tests { use super::*; + impl EmployeeVerifyPhoneNumberService { + pub fn mock_service( + times: Option, + _cmd: VerifyPhoneNumberCommand, + ) -> EmployeeVerifyPhoneNumberServiceObj { + let res = PhoneNumberVerifiedEvent::get_event(); + let mut m = MockEmployeeVerifyPhoneNumberUseCase::default(); + + if let Some(times) = times { + m.expect_verify_phone_number() + .times(times) + .returning(move |_| Ok(res.clone())); + } else { + m.expect_verify_phone_number() + .returning(move |_| Ok(res.clone())); + } + + std::sync::Arc::new(m) + } + } + #[actix_rt::test] async fn test_service_verify_phone_number() { let s = EmployeeVerifyPhoneNumberServiceBuilder::default() diff --git a/src/identity/domain/accept_invite_command.rs b/src/identity/domain/accept_invite_command.rs index d09b27a..d830463 100644 --- a/src/identity/domain/accept_invite_command.rs +++ b/src/identity/domain/accept_invite_command.rs @@ -16,3 +16,19 @@ pub struct AcceptInviteCommand { emp_id: Uuid, invite_id: Uuid, } + +#[cfg(test)] +mod tests { + use crate::utils::uuid::tests::UUID; + + use super::*; + + impl AcceptInviteCommand { + pub fn get_cmd() -> Self { + Self { + emp_id: UUID, + invite_id: UUID, + } + } + } +} diff --git a/src/identity/domain/employee_aggregate.rs b/src/identity/domain/employee_aggregate.rs index 52465c2..585854f 100644 --- a/src/identity/domain/employee_aggregate.rs +++ b/src/identity/domain/employee_aggregate.rs @@ -171,10 +171,28 @@ mod tests { use std::sync::Arc; use cqrs_es::test::TestFramework; + use employee_accept_invite_service::EmployeeAcceptInviteService; + use employee_exit_organization_service::EmployeeExitOrganizationService; use employee_login_service::EmployeeLoginService; + use employee_resend_login_otp_service::EmployeeResendLoginOTPService; + use employee_resend_verification_otp_service::EmployeeResendVerificationOTPService; + use employee_verify_phone_number_service::EmployeeVerifyPhoneNumberService; use crate::identity::domain::{ - employee_logged_in_event::{EmployeeInitLoggedInEvent, EmployeeLoggedInEvent}, employee_login_command::{EmployeeFinishLoginCommand, EmployeeInitLoginCommand}, employee_register_command::EmployeeRegisterCommand, employee_registered_event::EmployeeRegisteredEvent + accept_invite_command::AcceptInviteCommand, + employee_logged_in_event::{EmployeeInitLoggedInEvent, EmployeeLoggedInEvent}, + employee_login_command::{EmployeeFinishLoginCommand, EmployeeInitLoginCommand}, + employee_register_command::EmployeeRegisterCommand, + employee_registered_event::EmployeeRegisteredEvent, + exit_organization_command::ExitOrganizationCommand, + invite_accepted_event::InviteAcceptedEvent, + organization_exited_event::OrganizationExitedEvent, + phone_number_verified_event::PhoneNumberVerifiedEvent, + resend_login_otp_command::ResendLoginOTPCommand, + resend_login_otp_event::ResentLoginOTPEvent, + resend_verification_otp_command::ResendVerificationOTPCommand, + verification_otp_resent_event::VerificationOTPResentEvent, + verify_phone_number_command::VerifyPhoneNumberCommand, }; use employee_register_service::EmployeeRegisterUserService; @@ -204,48 +222,150 @@ mod tests { .then_expect_events(vec![expected]); } -// -// #[test] -// fn test_init_login() { -// let cmd = EmployeeInitLoginCommand::get_cmd(); -// let expected = EmployeeInitLoggedInEvent::get_event(); -// let expected = IdentityEvent::EmployeeInitLoggedIn(expected); -// -// let mut services = MockIdentityServicesInterface::new(); -// services -// .expect_employee_login_service() -// .times(IS_CALLED_ONLY_ONCE.unwrap()) -// .return_const(EmployeeLoginService::mock_init_login( -// IS_CALLED_ONLY_ONCE, -// cmd.clone(), -// )); -// -// EmployeeTestFramework::with(Arc::new(services)) -// .given_no_previous_events() -// .when(IdentityCommand::EmployeeInitLogin(cmd)) -// .then_expect_events(vec![expected]); -// } -// -// -// -// #[test] -// fn test_finish_login() { -// let cmd = EmployeeFinishLoginCommand::get_cmd(); -// let expected = EmployeeLoggedInEvent::get_event(); -// let expected = IdentityEvent::EmployeeLoggedIn(expected); -// -// let mut services = MockIdentityServicesInterface::new(); -// services -// .expect_employee_login_service() -// .times(IS_CALLED_ONLY_ONCE.unwrap()) -// .return_const(EmployeeLoginService::mock_finish_login( -// IS_CALLED_ONLY_ONCE, -// cmd.clone(), -// )); -// -// EmployeeTestFramework::with(Arc::new(services)) -// .given_no_previous_events() -// .when(IdentityCommand::EmployeeFinishLogin(cmd)) -// .then_expect_events(vec![expected]); -// } + #[test] + fn test_init_login() { + let cmd = EmployeeInitLoginCommand::get_cmd(); + let expected = EmployeeInitLoggedInEvent::get_event(); + let expected = IdentityEvent::EmployeeInitLoggedIn(expected); + + let mut services = MockIdentityServicesInterface::new(); + services + .expect_employee_login_service() + .times(IS_CALLED_ONLY_ONCE.unwrap()) + .return_const(EmployeeLoginService::mock_init_login( + IS_CALLED_ONLY_ONCE, + cmd.clone(), + )); + + EmployeeTestFramework::with(Arc::new(services)) + .given_no_previous_events() + .when(IdentityCommand::EmployeeInitLogin(cmd)) + .then_expect_events(vec![expected]); + } + + #[test] + fn test_finish_login() { + let cmd = EmployeeFinishLoginCommand::get_cmd(); + let expected = EmployeeLoggedInEvent::get_event(); + let expected = IdentityEvent::EmployeeLoggedIn(expected); + + let mut services = MockIdentityServicesInterface::new(); + services + .expect_employee_login_service() + .times(IS_CALLED_ONLY_ONCE.unwrap()) + .return_const(EmployeeLoginService::mock_finish_login( + IS_CALLED_ONLY_ONCE, + cmd.clone(), + )); + + EmployeeTestFramework::with(Arc::new(services)) + .given_no_previous_events() + .when(IdentityCommand::EmployeeFinishLogin(cmd)) + .then_expect_events(vec![expected]); + } + + #[test] + fn test_resend_login_otp() { + let cmd = ResendLoginOTPCommand::get_cmd(); + let expected = ResentLoginOTPEvent::get_event(); + let expected = IdentityEvent::ResentLoginOTP(expected); + + let mut services = MockIdentityServicesInterface::new(); + services + .expect_employee_resend_login_otp_service() + .times(IS_CALLED_ONLY_ONCE.unwrap()) + .return_const(EmployeeResendLoginOTPService::mock_service( + IS_CALLED_ONLY_ONCE, + cmd.clone(), + )); + + EmployeeTestFramework::with(Arc::new(services)) + .given_no_previous_events() + .when(IdentityCommand::EmployeeResendLoginOTP(cmd)) + .then_expect_events(vec![expected]); + } + + #[test] + fn test_verify_phone_number() { + let cmd = VerifyPhoneNumberCommand::get_cmd(); + let expected = PhoneNumberVerifiedEvent::get_event(); + let expected = IdentityEvent::PhoneNumberVerified(expected); + + let mut services = MockIdentityServicesInterface::new(); + services + .expect_employee_verify_phone_number_service() + .times(IS_CALLED_ONLY_ONCE.unwrap()) + .return_const(EmployeeVerifyPhoneNumberService::mock_service( + IS_CALLED_ONLY_ONCE, + cmd.clone(), + )); + + EmployeeTestFramework::with(Arc::new(services)) + .given_no_previous_events() + .when(IdentityCommand::EmployeeVerifyPhoneNumber(cmd)) + .then_expect_events(vec![expected]); + } + + #[test] + fn test_resend_verification_otp() { + let cmd = ResendVerificationOTPCommand::get_cmd(); + let expected = VerificationOTPResentEvent::get_event(); + let expected = IdentityEvent::VerificationOTPResent(expected); + + let mut services = MockIdentityServicesInterface::new(); + services + .expect_employee_resend_verification_otp_service() + .times(IS_CALLED_ONLY_ONCE.unwrap()) + .return_const(EmployeeResendVerificationOTPService::mock_service( + IS_CALLED_ONLY_ONCE, + cmd.clone(), + )); + + EmployeeTestFramework::with(Arc::new(services)) + .given_no_previous_events() + .when(IdentityCommand::EmployeeResendVerificationOTP(cmd)) + .then_expect_events(vec![expected]); + } + + #[test] + fn test_accept_invite() { + let cmd = AcceptInviteCommand::get_cmd(); + let expected = InviteAcceptedEvent::get_event(&cmd); + let expected = IdentityEvent::InviteAccepted(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]); + } + + #[test] + fn test_exit_organization() { + let cmd = ExitOrganizationCommand::get_cmd(); + let expected = OrganizationExitedEvent::get_event(&cmd); + let expected = IdentityEvent::OrganizationExited(expected); + + let mut services = MockIdentityServicesInterface::new(); + services + .expect_employee_exit_organization_service() + .times(IS_CALLED_ONLY_ONCE.unwrap()) + .return_const(EmployeeExitOrganizationService::mock_service( + IS_CALLED_ONLY_ONCE, + cmd.clone(), + )); + + EmployeeTestFramework::with(Arc::new(services)) + .given_no_previous_events() + .when(IdentityCommand::EmployeeExitOrganization(cmd)) + .then_expect_events(vec![expected]); + } } diff --git a/src/identity/domain/employee_login_command.rs b/src/identity/domain/employee_login_command.rs index 4007630..930783d 100644 --- a/src/identity/domain/employee_login_command.rs +++ b/src/identity/domain/employee_login_command.rs @@ -29,23 +29,19 @@ mod tests { use super::*; impl EmployeeInitLoginCommand { - - pub fn get_cmd() -> Self { - Self { - phone_number: PhoneNumber::default() - } - } - } - - - impl EmployeeFinishLoginCommand { - pub fn get_cmd() -> Self { Self { phone_number: PhoneNumber::default(), - otp: 999, } + } + } + impl EmployeeFinishLoginCommand { + pub fn get_cmd() -> Self { + Self { + phone_number: PhoneNumber::default(), + otp: 999, + } } } } diff --git a/src/identity/domain/exit_organization_command.rs b/src/identity/domain/exit_organization_command.rs index 0a486e6..015c065 100644 --- a/src/identity/domain/exit_organization_command.rs +++ b/src/identity/domain/exit_organization_command.rs @@ -16,3 +16,19 @@ pub struct ExitOrganizationCommand { emp_id: Uuid, store_id: Uuid, } + +#[cfg(test)] +mod tests { + use crate::utils::uuid::tests::UUID; + + use super::*; + + impl ExitOrganizationCommand { + pub fn get_cmd() -> Self { + Self { + emp_id: UUID, + store_id: UUID, + } + } + } +} diff --git a/src/identity/domain/invite_accepted_event.rs b/src/identity/domain/invite_accepted_event.rs index 397ba1f..e1e7d2e 100644 --- a/src/identity/domain/invite_accepted_event.rs +++ b/src/identity/domain/invite_accepted_event.rs @@ -17,3 +17,21 @@ pub struct InviteAcceptedEvent { invite_id: Uuid, store_id: Uuid, } + +#[cfg(test)] +mod tests { + use super::*; + use crate::{ + identity::domain::accept_invite_command::AcceptInviteCommand, utils::uuid::tests::UUID, + }; + + impl InviteAcceptedEvent { + pub fn get_event(cmd: &AcceptInviteCommand) -> Self { + Self { + emp_id: *cmd.emp_id(), + invite_id: *cmd.invite_id(), + store_id: UUID, + } + } + } +} diff --git a/src/identity/domain/organization_exited_event.rs b/src/identity/domain/organization_exited_event.rs index 7e68404..65dfaf4 100644 --- a/src/identity/domain/organization_exited_event.rs +++ b/src/identity/domain/organization_exited_event.rs @@ -16,3 +16,19 @@ pub struct OrganizationExitedEvent { emp_id: Uuid, store_id: Uuid, } + +#[cfg(test)] +mod tests { + use crate::identity::domain::exit_organization_command::ExitOrganizationCommand; + + use super::*; + + impl OrganizationExitedEvent { + pub fn get_event(cmd: &ExitOrganizationCommand) -> Self { + Self { + emp_id: *cmd.emp_id(), + store_id: *cmd.store_id(), + } + } + } +} diff --git a/src/identity/domain/phone_number_verified_event.rs b/src/identity/domain/phone_number_verified_event.rs index f7609a5..489270e 100644 --- a/src/identity/domain/phone_number_verified_event.rs +++ b/src/identity/domain/phone_number_verified_event.rs @@ -15,3 +15,16 @@ use super::employee_aggregate::*; pub struct PhoneNumberVerifiedEvent { emp_id: Uuid, } + +#[cfg(test)] +mod tests { + use crate::utils::uuid::tests::UUID; + + use super::*; + + impl PhoneNumberVerifiedEvent { + pub fn get_event() -> Self { + Self { emp_id: UUID } + } + } +} diff --git a/src/identity/domain/resend_login_otp_command.rs b/src/identity/domain/resend_login_otp_command.rs index 03e9155..1fc72f7 100644 --- a/src/identity/domain/resend_login_otp_command.rs +++ b/src/identity/domain/resend_login_otp_command.rs @@ -15,3 +15,16 @@ use super::employee_aggregate::*; pub struct ResendLoginOTPCommand { phone_number: PhoneNumber, } + +#[cfg(test)] +mod tests { + use super::*; + + impl ResendLoginOTPCommand { + pub fn get_cmd() -> Self { + Self { + phone_number: Default::default(), + } + } + } +} diff --git a/src/identity/domain/resend_login_otp_event.rs b/src/identity/domain/resend_login_otp_event.rs index a0143dd..2a267ae 100644 --- a/src/identity/domain/resend_login_otp_event.rs +++ b/src/identity/domain/resend_login_otp_event.rs @@ -15,3 +15,16 @@ use super::employee_aggregate::*; pub struct ResentLoginOTPEvent { emp_id: Uuid, } + +#[cfg(test)] +mod tests { + use crate::utils::uuid::tests::UUID; + + use super::*; + + impl ResentLoginOTPEvent { + pub fn get_event() -> Self { + Self { emp_id: UUID } + } + } +} diff --git a/src/identity/domain/resend_verification_otp_command.rs b/src/identity/domain/resend_verification_otp_command.rs index b4b6955..6dad626 100644 --- a/src/identity/domain/resend_verification_otp_command.rs +++ b/src/identity/domain/resend_verification_otp_command.rs @@ -15,3 +15,16 @@ use super::employee_aggregate::*; pub struct ResendVerificationOTPCommand { phone_number: PhoneNumber, } + +#[cfg(test)] +mod tests { + use super::*; + + impl ResendVerificationOTPCommand { + pub fn get_cmd() -> Self { + Self { + phone_number: Default::default(), + } + } + } +} diff --git a/src/identity/domain/verification_otp_resent_event.rs b/src/identity/domain/verification_otp_resent_event.rs index 282411c..1379166 100644 --- a/src/identity/domain/verification_otp_resent_event.rs +++ b/src/identity/domain/verification_otp_resent_event.rs @@ -14,3 +14,16 @@ use super::employee_aggregate::*; pub struct VerificationOTPResentEvent { emp_id: Uuid, } + +#[cfg(test)] +mod tests { + use crate::utils::uuid::tests::UUID; + + use super::*; + + impl VerificationOTPResentEvent { + pub fn get_event() -> Self { + Self { emp_id: UUID } + } + } +} diff --git a/src/identity/domain/verify_phone_number_command.rs b/src/identity/domain/verify_phone_number_command.rs index 4d8d636..438f00c 100644 --- a/src/identity/domain/verify_phone_number_command.rs +++ b/src/identity/domain/verify_phone_number_command.rs @@ -16,3 +16,17 @@ pub struct VerifyPhoneNumberCommand { phone_number: PhoneNumber, otp: usize, } + +#[cfg(test)] +mod tests { + use super::*; + + impl VerifyPhoneNumberCommand { + pub fn get_cmd() -> Self { + Self { + phone_number: Default::default(), + otp: 999, + } + } + } +}