From 20828fb4a14b76cce6f943abb600a1d714a20243 Mon Sep 17 00:00:00 2001 From: Simon Goller Date: Fri, 3 May 2024 19:01:26 +0200 Subject: [PATCH] Add context reqruied later for authentication --- app/src/main.rs | 12 - rest/src/hello.rs | 14 - rest/src/lib.rs | 13 +- rest/src/permission.rs | 23 +- rest/src/slot.rs | 8 +- service/src/lib.rs | 16 +- service/src/permission.rs | 67 ++++- service/src/slot.rs | 14 +- service/src/user_service.rs | 14 + service_impl/src/lib.rs | 42 +-- service_impl/src/permission.rs | 109 +++++-- service_impl/src/slot.rs | 36 ++- service_impl/src/test/permission_test.rs | 77 ++--- service_impl/src/test/slot.rs | 348 ++++++++++++++--------- 14 files changed, 463 insertions(+), 330 deletions(-) delete mode 100644 rest/src/hello.rs create mode 100644 service/src/user_service.rs diff --git a/app/src/main.rs b/app/src/main.rs index a4f6a49..ce03020 100644 --- a/app/src/main.rs +++ b/app/src/main.rs @@ -4,7 +4,6 @@ use sqlx::SqlitePool; type PermissionService = service_impl::PermissionServiceImpl; -type HelloService = service_impl::HelloServiceImpl; type ClockService = service_impl::clock::ClockServiceImpl; type UuidService = service_impl::uuid_service::UuidServiceImpl; type SlotService = service_impl::slot::SlotServiceImpl< @@ -16,18 +15,13 @@ type SlotService = service_impl::slot::SlotServiceImpl< #[derive(Clone)] pub struct RestStateImpl { - hello_service: Arc, permission_service: Arc, slot_service: Arc, } impl rest::RestStateDef for RestStateImpl { - type HelloService = HelloService; type PermissionService = PermissionService; type SlotService = SlotService; - fn hello_service(&self) -> Arc { - self.hello_service.clone() - } fn permission_service(&self) -> Arc { self.permission_service.clone() } @@ -37,7 +31,6 @@ impl rest::RestStateDef for RestStateImpl { } impl RestStateImpl { pub fn new(pool: Arc>) -> Self { - let hello_dao = dao_impl::HelloDaoImpl::new(pool.clone()); let permission_dao = dao_impl::PermissionDaoImpl::new(pool.clone()); let slot_dao = dao_impl::slot::SlotDaoImpl::new(pool); @@ -52,10 +45,6 @@ impl RestStateImpl { permission_dao.into(), user_service.into(), )); - let hello_service = Arc::new(service_impl::HelloServiceImpl::new( - hello_dao.into(), - permission_service.clone(), - )); let clock_service = Arc::new(service_impl::clock::ClockServiceImpl); let uuid_service = Arc::new(service_impl::uuid_service::UuidServiceImpl); let slot_service = Arc::new(service_impl::slot::SlotServiceImpl::new( @@ -65,7 +54,6 @@ impl RestStateImpl { uuid_service, )); Self { - hello_service, permission_service, slot_service, } diff --git a/rest/src/hello.rs b/rest/src/hello.rs deleted file mode 100644 index 4e9ae6b..0000000 --- a/rest/src/hello.rs +++ /dev/null @@ -1,14 +0,0 @@ -use axum::{extract::State, response::Response}; - -use crate::{error_handler, RestStateDef, RoString}; -use service::HelloService; - -pub async fn hello(State(rest_state): State) -> Response { - error_handler( - (async { - let string = rest_state.hello_service().hello().await?; - Ok(RoString::from(string).into()) - }) - .await, - ) -} diff --git a/rest/src/lib.rs b/rest/src/lib.rs index 37e2641..0fd6764 100644 --- a/rest/src/lib.rs +++ b/rest/src/lib.rs @@ -1,13 +1,15 @@ use std::{convert::Infallible, sync::Arc}; -mod hello; mod permission; mod slot; -use axum::{body::Body, response::Response, routing::get, Router}; +use axum::{body::Body, response::Response, Router}; use thiserror::Error; use uuid::Uuid; +// TODO: In prod, it must be a different type than in dev mode. +type Context = (); + pub struct RoString(Arc, bool); impl http_body::Body for RoString { type Data = bytes::Bytes; @@ -125,18 +127,15 @@ fn error_handler(result: Result) -> Response { } pub trait RestStateDef: Clone + Send + Sync + 'static { - type HelloService: service::HelloService + Send + Sync + 'static; - type PermissionService: service::PermissionService + Send + Sync + 'static; - type SlotService: service::slot::SlotService + Send + Sync + 'static; + type PermissionService: service::PermissionService + Send + Sync + 'static; + type SlotService: service::slot::SlotService + Send + Sync + 'static; - fn hello_service(&self) -> Arc; fn permission_service(&self) -> Arc; fn slot_service(&self) -> Arc; } pub async fn start_server(rest_state: RestState) { let app = Router::new() - .route("/", get(hello::hello::)) .nest("/permission", permission::generate_route()) .nest("/slot", slot::generate_route()) .with_state(rest_state); diff --git a/rest/src/permission.rs b/rest/src/permission.rs index 2b2d5d2..bce8207 100644 --- a/rest/src/permission.rs +++ b/rest/src/permission.rs @@ -87,7 +87,7 @@ pub async fn add_user( (async { rest_state .permission_service() - .create_user(user.name.as_str()) + .create_user(user.name.as_str(), ()) .await?; Ok(Response::builder() .status(201) @@ -105,7 +105,10 @@ pub async fn remove_user( println!("Removing user: {:?}", user); error_handler( (async { - rest_state.permission_service().delete_user(&user).await?; + rest_state + .permission_service() + .delete_user(&user, ()) + .await?; Ok(Response::builder() .status(200) .body(Body::from("")) @@ -123,7 +126,7 @@ pub async fn add_role( (async { rest_state .permission_service() - .create_role(role.name.as_str()) + .create_role(role.name.as_str(), ()) .await?; Ok(Response::builder() .status(200) @@ -142,7 +145,7 @@ pub async fn delete_role( (async { rest_state .permission_service() - .delete_role(role.as_str()) + .delete_role(role.as_str(), ()) .await?; Ok(Response::builder() .status(200) @@ -161,7 +164,7 @@ pub async fn add_user_role( (async { rest_state .permission_service() - .add_user_role(user_role.user.as_str(), user_role.role.as_str()) + .add_user_role(user_role.user.as_str(), user_role.role.as_str(), ()) .await?; Ok(Response::builder() .status(201) @@ -180,7 +183,7 @@ pub async fn remove_user_role( (async { rest_state .permission_service() - .delete_user_role(user_role.user.as_str(), user_role.role.as_str()) + .delete_user_role(user_role.user.as_str(), user_role.role.as_str(), ()) .await?; Ok(Response::builder() .status(200) @@ -202,6 +205,7 @@ pub async fn add_role_privilege( .add_role_privilege( role_privilege.role.as_str(), role_privilege.privilege.as_str(), + (), ) .await?; Ok(Response::builder() @@ -224,6 +228,7 @@ pub async fn remove_role_privilege( .delete_role_privilege( role_privilege.role.as_str(), role_privilege.privilege.as_str(), + (), ) .await?; Ok(Response::builder() @@ -240,7 +245,7 @@ pub async fn get_all_users(rest_state: State (async { let users: Arc<[UserTO]> = rest_state .permission_service() - .get_all_users() + .get_all_users(()) .await? .iter() .map(UserTO::from) @@ -259,7 +264,7 @@ pub async fn get_all_roles(rest_state: State (async { let roles: Arc<[RoleTO]> = rest_state .permission_service() - .get_all_roles() + .get_all_roles(()) .await? .iter() .map(RoleTO::from) @@ -278,7 +283,7 @@ pub async fn get_all_privileges(rest_state: State = rest_state .permission_service() - .get_all_privileges() + .get_all_privileges(()) .await? .iter() .map(PrivilegeTO::from) diff --git a/rest/src/slot.rs b/rest/src/slot.rs index 44dcf37..5569b3a 100644 --- a/rest/src/slot.rs +++ b/rest/src/slot.rs @@ -107,7 +107,7 @@ pub async fn get_all_slots(rest_state: State (async { let slots: Arc<[SlotTO]> = rest_state .slot_service() - .get_slots() + .get_slots(()) .await? .iter() .map(SlotTO::from) @@ -127,7 +127,7 @@ pub async fn get_slot( ) -> Response { error_handler( (async { - let slot = SlotTO::from(&rest_state.slot_service().get_slot(&slot_id).await?.into()); + let slot = SlotTO::from(&rest_state.slot_service().get_slot(&slot_id, ()).await?); Ok(Response::builder() .status(200) .body(Body::new(serde_json::to_string(&slot).unwrap())) @@ -146,7 +146,7 @@ pub async fn create_slot( let slot = SlotTO::from( &rest_state .slot_service() - .create_slot(&(&slot).into()) + .create_slot(&(&slot).into(), ()) .await?, ); Ok(Response::builder() @@ -170,7 +170,7 @@ pub async fn update_slot( } rest_state .slot_service() - .update_slot(&(&slot).into()) + .update_slot(&(&slot).into(), ()) .await?; Ok(Response::builder() .status(200) diff --git a/service/src/lib.rs b/service/src/lib.rs index fe64ce4..7da8309 100644 --- a/service/src/lib.rs +++ b/service/src/lib.rs @@ -1,6 +1,4 @@ -use async_trait::async_trait; -use mockall::automock; -use std::{future::Future, sync::Arc}; +use std::sync::Arc; use thiserror::Error; use time::Date; use time::Time; @@ -9,6 +7,7 @@ use uuid::Uuid; pub mod clock; pub mod permission; pub mod slot; +pub mod user_service; pub mod uuid_service; pub use permission::MockPermissionService; @@ -57,14 +56,3 @@ pub enum ServiceError { #[error("Date order wrong. {0} must is not smaller or equal to {1}")] DateOrderWrong(Date, Date), } - -#[automock] -pub trait HelloService { - fn hello(&self) -> impl Future, ServiceError>> + Send; -} - -#[automock] -#[async_trait] -pub trait UserService { - async fn current_user(&self) -> Result, ServiceError>; -} diff --git a/service/src/permission.rs b/service/src/permission.rs index 1be3152..45476e1 100644 --- a/service/src/permission.rs +++ b/service/src/permission.rs @@ -41,25 +41,62 @@ impl From<&dao::PrivilegeEntity> for Privilege { } } -#[automock] +#[automock(type Context=();)] #[async_trait] pub trait PermissionService { - async fn check_permission(&self, privilege: &str) -> Result<(), ServiceError>; + type Context: Clone + Send + Sync + 'static; - async fn create_user(&self, user: &str) -> Result<(), ServiceError>; - async fn delete_user(&self, user: &str) -> Result<(), ServiceError>; - async fn get_all_users(&self) -> Result, ServiceError>; + async fn check_permission( + &self, + privilege: &str, + context: Self::Context, + ) -> Result<(), ServiceError>; - async fn create_role(&self, role: &str) -> Result<(), ServiceError>; - async fn delete_role(&self, role: &str) -> Result<(), ServiceError>; - async fn get_all_roles(&self) -> Result, ServiceError>; + async fn create_user(&self, user: &str, context: Self::Context) -> Result<(), ServiceError>; + async fn delete_user(&self, user: &str, context: Self::Context) -> Result<(), ServiceError>; + async fn get_all_users(&self, context: Self::Context) -> Result, ServiceError>; - async fn create_privilege(&self, privilege: &str) -> Result<(), ServiceError>; - async fn delete_privilege(&self, privilege: &str) -> Result<(), ServiceError>; - async fn get_all_privileges(&self) -> Result, ServiceError>; + async fn create_role(&self, role: &str, context: Self::Context) -> Result<(), ServiceError>; + async fn delete_role(&self, role: &str, context: Self::Context) -> Result<(), ServiceError>; + async fn get_all_roles(&self, context: Self::Context) -> Result, ServiceError>; - async fn add_user_role(&self, user: &str, role: &str) -> Result<(), ServiceError>; - async fn add_role_privilege(&self, role: &str, privilege: &str) -> Result<(), ServiceError>; - async fn delete_role_privilege(&self, role: &str, privilege: &str) -> Result<(), ServiceError>; - async fn delete_user_role(&self, user: &str, role: &str) -> Result<(), ServiceError>; + async fn create_privilege( + &self, + privilege: &str, + context: Self::Context, + ) -> Result<(), ServiceError>; + async fn delete_privilege( + &self, + privilege: &str, + context: Self::Context, + ) -> Result<(), ServiceError>; + async fn get_all_privileges( + &self, + context: Self::Context, + ) -> Result, ServiceError>; + + async fn add_user_role( + &self, + user: &str, + role: &str, + context: Self::Context, + ) -> Result<(), ServiceError>; + async fn add_role_privilege( + &self, + role: &str, + privilege: &str, + context: Self::Context, + ) -> Result<(), ServiceError>; + async fn delete_role_privilege( + &self, + role: &str, + privilege: &str, + context: Self::Context, + ) -> Result<(), ServiceError>; + async fn delete_user_role( + &self, + user: &str, + role: &str, + context: Self::Context, + ) -> Result<(), ServiceError>; } diff --git a/service/src/slot.rs b/service/src/slot.rs index 63b4348..6fd7e28 100644 --- a/service/src/slot.rs +++ b/service/src/slot.rs @@ -82,12 +82,14 @@ impl From<&Slot> for dao::slot::SlotEntity { } } -#[automock] +#[automock(type Context=();)] #[async_trait] pub trait SlotService { - async fn get_slots(&self) -> Result, ServiceError>; - async fn get_slot(&self, id: &Uuid) -> Result; - async fn create_slot(&self, slot: &Slot) -> Result; - async fn delete_slot(&self, id: &Uuid) -> Result<(), ServiceError>; - async fn update_slot(&self, slot: &Slot) -> Result<(), ServiceError>; + type Context: Clone + Send + Sync + 'static; + + async fn get_slots(&self, context: Self::Context) -> Result, ServiceError>; + async fn get_slot(&self, id: &Uuid, context: Self::Context) -> Result; + async fn create_slot(&self, slot: &Slot, context: Self::Context) -> Result; + async fn delete_slot(&self, id: &Uuid, context: Self::Context) -> Result<(), ServiceError>; + async fn update_slot(&self, slot: &Slot, context: Self::Context) -> Result<(), ServiceError>; } diff --git a/service/src/user_service.rs b/service/src/user_service.rs new file mode 100644 index 0000000..eca005b --- /dev/null +++ b/service/src/user_service.rs @@ -0,0 +1,14 @@ +use std::sync::Arc; + +use async_trait::async_trait; +use mockall::automock; + +use crate::ServiceError; + +#[automock(type Context=();)] +#[async_trait] +pub trait UserService { + type Context: Clone + Send + Sync + 'static; + + async fn current_user(&self, context: Self::Context) -> Result, ServiceError>; +} diff --git a/service_impl/src/lib.rs b/service_impl/src/lib.rs index f77eacc..e9fe606 100644 --- a/service_impl/src/lib.rs +++ b/service_impl/src/lib.rs @@ -10,44 +10,16 @@ pub mod uuid_service; pub use permission::PermissionServiceImpl; -pub struct HelloServiceImpl -where - HelloDao: dao::HelloDao + Sync + Send, - PermissionService: service::PermissionService + Sync + Send, -{ - hello_dao: Arc, - permission_service: Arc, -} -impl HelloServiceImpl -where - HelloDao: dao::HelloDao + Sync + Send, - PermissionService: service::PermissionService + Sync + Send, -{ - pub fn new(hello_dao: Arc, permission_service: Arc) -> Self { - Self { - hello_dao, - permission_service, - } - } -} - -impl service::HelloService - for HelloServiceImpl -where - HelloDao: dao::HelloDao + Sync + Send, - PermissionService: service::PermissionService + Sync + Send, -{ - async fn hello(&self) -> Result, service::ServiceError> { - self.permission_service.check_permission("hello").await?; - Ok(self.hello_dao.get_hello().await?) - } -} - pub struct UserServiceDev; #[async_trait] -impl service::UserService for UserServiceDev { - async fn current_user(&self) -> Result, service::ServiceError> { +impl service::user_service::UserService for UserServiceDev { + type Context = (); + + async fn current_user( + &self, + _context: Self::Context, + ) -> Result, service::ServiceError> { Ok("DEVUSER".into()) } } diff --git a/service_impl/src/permission.rs b/service_impl/src/permission.rs index 85d733c..ffa9561 100644 --- a/service_impl/src/permission.rs +++ b/service_impl/src/permission.rs @@ -5,7 +5,7 @@ use async_trait::async_trait; pub struct PermissionServiceImpl where PermissionDao: dao::PermissionDao + Send + Sync, - UserService: service::UserService + Send + Sync, + UserService: service::user_service::UserService + Send + Sync, { permission_dao: Arc, user_service: Arc, @@ -13,7 +13,7 @@ where impl PermissionServiceImpl where PermissionDao: dao::PermissionDao + Send + Sync, - UserService: service::UserService + Send + Sync, + UserService: service::user_service::UserService + Send + Sync, { pub fn new(permission_dao: Arc, user_service: Arc) -> Self { Self { @@ -30,10 +30,16 @@ impl service::PermissionService for PermissionServiceImpl where PermissionDao: dao::PermissionDao + Send + Sync, - UserService: service::UserService + Send + Sync, + UserService: service::user_service::UserService + Send + Sync, { - async fn check_permission(&self, privilege: &str) -> Result<(), service::ServiceError> { - let current_user = self.user_service.current_user().await?; + type Context = UserService::Context; + + async fn check_permission( + &self, + privilege: &str, + context: Self::Context, + ) -> Result<(), service::ServiceError> { + let current_user = self.user_service.current_user(context).await?; if self .permission_dao .has_privilege(current_user.as_ref(), privilege) @@ -45,8 +51,12 @@ where } } - async fn create_user(&self, user: &str) -> Result<(), service::ServiceError> { - self.check_permission("admin").await?; + async fn create_user( + &self, + user: &str, + context: Self::Context, + ) -> Result<(), service::ServiceError> { + self.check_permission("admin", context).await?; self.permission_dao .create_user( &dao::UserEntity { name: user.into() }, @@ -55,14 +65,21 @@ where .await?; Ok(()) } - async fn delete_user(&self, user: &str) -> Result<(), service::ServiceError> { - self.check_permission("admin").await?; + async fn delete_user( + &self, + user: &str, + context: Self::Context, + ) -> Result<(), service::ServiceError> { + self.check_permission("admin", context).await?; self.permission_dao.delete_user(user).await?; Ok(()) } - async fn get_all_users(&self) -> Result, service::ServiceError> { - self.check_permission("admin").await?; + async fn get_all_users( + &self, + context: Self::Context, + ) -> Result, service::ServiceError> { + self.check_permission("admin", context).await?; Ok(self .permission_dao .all_users() @@ -72,8 +89,12 @@ where .collect()) } - async fn create_role(&self, role: &str) -> Result<(), service::ServiceError> { - self.check_permission("admin").await?; + async fn create_role( + &self, + role: &str, + context: Self::Context, + ) -> Result<(), service::ServiceError> { + self.check_permission("admin", context).await?; self.permission_dao .create_role( &dao::RoleEntity { name: role.into() }, @@ -82,13 +103,20 @@ where .await?; Ok(()) } - async fn delete_role(&self, role: &str) -> Result<(), service::ServiceError> { - self.check_permission("admin").await?; + async fn delete_role( + &self, + role: &str, + context: Self::Context, + ) -> Result<(), service::ServiceError> { + self.check_permission("admin", context).await?; self.permission_dao.delete_role(role).await?; Ok(()) } - async fn get_all_roles(&self) -> Result, service::ServiceError> { - self.check_permission("admin").await?; + async fn get_all_roles( + &self, + context: Self::Context, + ) -> Result, service::ServiceError> { + self.check_permission("admin", context).await?; Ok(self .permission_dao .all_roles() @@ -98,8 +126,12 @@ where .collect()) } - async fn create_privilege(&self, privilege: &str) -> Result<(), service::ServiceError> { - self.check_permission("admin").await?; + async fn create_privilege( + &self, + privilege: &str, + context: Self::Context, + ) -> Result<(), service::ServiceError> { + self.check_permission("admin", context).await?; self.permission_dao .create_privilege( &dao::PrivilegeEntity { @@ -111,13 +143,20 @@ where Ok(()) } - async fn delete_privilege(&self, privilege: &str) -> Result<(), service::ServiceError> { - self.check_permission("admin").await?; + async fn delete_privilege( + &self, + privilege: &str, + context: Self::Context, + ) -> Result<(), service::ServiceError> { + self.check_permission("admin", context).await?; self.permission_dao.delete_privilege(privilege).await?; Ok(()) } - async fn get_all_privileges(&self) -> Result, service::ServiceError> { - self.check_permission("admin").await?; + async fn get_all_privileges( + &self, + context: Self::Context, + ) -> Result, service::ServiceError> { + self.check_permission("admin", context).await?; Ok(self .permission_dao .all_privileges() @@ -127,8 +166,13 @@ where .collect()) } - async fn add_user_role(&self, user: &str, role: &str) -> Result<(), service::ServiceError> { - self.check_permission("admin").await?; + async fn add_user_role( + &self, + user: &str, + role: &str, + context: Self::Context, + ) -> Result<(), service::ServiceError> { + self.check_permission("admin", context).await?; self.permission_dao .add_user_role(user, role, PERMISSION_SERVICE_PROCESS) .await?; @@ -138,8 +182,9 @@ where &self, role: &str, privilege: &str, + context: Self::Context, ) -> Result<(), service::ServiceError> { - self.check_permission("admin").await?; + self.check_permission("admin", context).await?; self.permission_dao .add_role_privilege(role, privilege, PERMISSION_SERVICE_PROCESS) .await?; @@ -149,15 +194,21 @@ where &self, role: &str, privilege: &str, + context: Self::Context, ) -> Result<(), service::ServiceError> { - self.check_permission("admin").await?; + self.check_permission("admin", context).await?; self.permission_dao .delete_role_privilege(role, privilege) .await?; Ok(()) } - async fn delete_user_role(&self, user: &str, role: &str) -> Result<(), service::ServiceError> { - self.check_permission("admin").await?; + async fn delete_user_role( + &self, + user: &str, + role: &str, + context: Self::Context, + ) -> Result<(), service::ServiceError> { + self.check_permission("admin", context).await?; self.permission_dao.delete_user_role(user, role).await?; Ok(()) } diff --git a/service_impl/src/slot.rs b/service_impl/src/slot.rs index f0f5356..9e1a0a3 100644 --- a/service_impl/src/slot.rs +++ b/service_impl/src/slot.rs @@ -58,10 +58,13 @@ where ClockService: service::clock::ClockService + Send + Sync, UuidService: service::uuid_service::UuidService + Send + Sync, { - async fn get_slots(&self) -> Result, ServiceError> { + type Context = PermissionService::Context; + + async fn get_slots(&self, context: Self::Context) -> Result, ServiceError> { let (hr_permission, sales_permission) = join!( - self.permission_service.check_permission("hr"), - self.permission_service.check_permission("sales"), + self.permission_service + .check_permission("hr", context.clone()), + self.permission_service.check_permission("sales", context), ); hr_permission.or(sales_permission)?; @@ -73,10 +76,11 @@ where .map(Slot::from) .collect()) } - async fn get_slot(&self, id: &Uuid) -> Result { + async fn get_slot(&self, id: &Uuid, context: Self::Context) -> Result { let (hr_permission, sales_permission) = join!( - self.permission_service.check_permission("hr"), - self.permission_service.check_permission("sales"), + self.permission_service + .check_permission("hr", context.clone()), + self.permission_service.check_permission("sales", context), ); hr_permission.or(sales_permission)?; @@ -87,8 +91,10 @@ where .ok_or_else(move || ServiceError::EntityNotFound(*id))?; Ok(slot) } - async fn create_slot(&self, slot: &Slot) -> Result { - self.permission_service.check_permission("hr").await?; + async fn create_slot(&self, slot: &Slot, context: Self::Context) -> Result { + self.permission_service + .check_permission("hr", context.clone()) + .await?; if slot.id != Uuid::nil() { return Err(ServiceError::IdSetOnCreate); @@ -107,7 +113,7 @@ where } if self - .get_slots() + .get_slots(context) .await? .iter() .any(|s| test_overlapping_slots(slot, s)) @@ -126,8 +132,10 @@ where Ok(slot) } - async fn delete_slot(&self, id: &Uuid) -> Result<(), ServiceError> { - self.permission_service.check_permission("hr").await?; + async fn delete_slot(&self, id: &Uuid, context: Self::Context) -> Result<(), ServiceError> { + self.permission_service + .check_permission("hr", context) + .await?; let mut slot = self .slot_dao .get_slot(id) @@ -139,8 +147,10 @@ where .await?; Ok(()) } - async fn update_slot(&self, slot: &Slot) -> Result<(), ServiceError> { - self.permission_service.check_permission("hr").await?; + async fn update_slot(&self, slot: &Slot, context: Self::Context) -> Result<(), ServiceError> { + self.permission_service + .check_permission("hr", context) + .await?; let persisted_slot = self .slot_dao .get_slot(&slot.id) diff --git a/service_impl/src/test/permission_test.rs b/service_impl/src/test/permission_test.rs index 1af02dc..91e1d9d 100644 --- a/service_impl/src/test/permission_test.rs +++ b/service_impl/src/test/permission_test.rs @@ -7,17 +7,20 @@ use tokio; fn generate_dependencies_mocks_permission( grant: bool, privilege: &'static str, -) -> (dao::MockPermissionDao, service::MockUserService) { +) -> ( + dao::MockPermissionDao, + service::user_service::MockUserService, +) { let mut permission_dao = dao::MockPermissionDao::new(); permission_dao .expect_has_privilege() .with(eq("DEVUSER"), eq(privilege)) .returning(move |_, _| Ok(grant)); - let mut user_service = service::MockUserService::new(); + let mut user_service = service::user_service::MockUserService::new(); user_service .expect_current_user() - .returning(|| Ok("DEVUSER".into())); + .returning(|_| Ok("DEVUSER".into())); (permission_dao, user_service) } @@ -27,7 +30,7 @@ async fn test_check_permission() { let permission_service = PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); - let result = permission_service.check_permission("hello").await; + let result = permission_service.check_permission("hello", ()).await; result.expect("Expected successful authorization"); } @@ -37,17 +40,17 @@ async fn test_check_permission_denied() { let permission_service = PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); - let result = permission_service.check_permission("hello").await; + let result = permission_service.check_permission("hello", ()).await; test_forbidden(&result); } #[tokio::test] async fn test_user_service_dev() { - use service::UserService; + use service::user_service::UserService; let user_service = UserServiceDev; assert_eq!( "DEVUSER", - user_service.current_user().await.unwrap().as_ref() + user_service.current_user(()).await.unwrap().as_ref() ); } @@ -68,7 +71,7 @@ async fn test_create_user() { let permission_service = PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); permission_service - .create_user("testuser") + .create_user("testuser", ()) .await .expect("Extected successful user creation"); } @@ -78,7 +81,7 @@ async fn test_create_user_without_permission() { let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin"); let permission_service = PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); - test_forbidden(&permission_service.create_user("testuser").await); + test_forbidden(&permission_service.create_user("testuser", ()).await); } #[tokio::test] @@ -94,7 +97,7 @@ async fn test_delete_user() { PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); permission_service - .delete_user("testuser") + .delete_user("testuser", ()) .await .expect("Expected successful delete"); } @@ -103,7 +106,7 @@ async fn test_delete_user_without_permission() { let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin"); let permission_service = PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); - test_forbidden(&permission_service.delete_user("testuser").await); + test_forbidden(&permission_service.delete_user("testuser", ()).await); } #[tokio::test] @@ -123,7 +126,7 @@ async fn test_create_role() { let permission_service = PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); permission_service - .create_role("testrole") + .create_role("testrole", ()) .await .expect("Extected successful role creation"); } @@ -133,7 +136,7 @@ async fn test_create_role_without_permission() { let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin"); let permission_service = PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); - test_forbidden(&permission_service.create_role("testrole").await); + test_forbidden(&permission_service.create_role("testrole", ()).await); } #[tokio::test] @@ -149,7 +152,7 @@ async fn test_delete_role() { PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); permission_service - .delete_role("testrole") + .delete_role("testrole", ()) .await .expect("Expected successful delete"); } @@ -159,7 +162,7 @@ async fn test_delete_role_without_permission() { let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin"); let permission_service = PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); - test_forbidden(&permission_service.delete_role("testrole").await); + test_forbidden(&permission_service.delete_role("testrole", ()).await); } #[tokio::test] @@ -180,7 +183,7 @@ async fn test_create_privilege() { PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); permission_service - .create_privilege("testprivilege") + .create_privilege("testprivilege", ()) .await .expect("Extected successful privilege creation"); } @@ -189,7 +192,11 @@ async fn test_create_privilege_without_permission() { let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin"); let permission_service = PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); - test_forbidden(&permission_service.create_privilege("testprivilege").await); + test_forbidden( + &permission_service + .create_privilege("testprivilege", ()) + .await, + ); } #[tokio::test] @@ -205,7 +212,7 @@ async fn test_delete_privilege() { PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); permission_service - .delete_privilege("testprivilege") + .delete_privilege("testprivilege", ()) .await .expect("Expected successful delete"); } @@ -215,7 +222,11 @@ async fn test_delete_privilege_without_permission() { let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin"); let permission_service = PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); - test_forbidden(&permission_service.delete_privilege("testprivilege").await); + test_forbidden( + &permission_service + .delete_privilege("testprivilege", ()) + .await, + ); } #[tokio::test] @@ -231,7 +242,7 @@ async fn test_add_user_role() { PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); permission_service - .add_user_role("testuser", "testrole") + .add_user_role("testuser", "testrole", ()) .await .expect("Extected successful user role creation"); } @@ -243,7 +254,7 @@ async fn test_add_user_role_without_permission() { PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); test_forbidden( &permission_service - .add_user_role("testuser", "testrole") + .add_user_role("testuser", "testrole", ()) .await, ); } @@ -265,7 +276,7 @@ async fn test_add_role_privilege() { PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); permission_service - .add_role_privilege("testrole", "testprivilege") + .add_role_privilege("testrole", "testprivilege", ()) .await .expect("Extected successful role privilege creation"); } @@ -277,7 +288,7 @@ async fn test_add_role_privilege_without_permission() { PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); test_forbidden( &permission_service - .add_role_privilege("testrole", "testprivilege") + .add_role_privilege("testrole", "testprivilege", ()) .await, ); } @@ -295,7 +306,7 @@ async fn test_delete_role_privilege() { PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); permission_service - .delete_role_privilege("testrole", "testprivilege") + .delete_role_privilege("testrole", "testprivilege", ()) .await .expect("Extected successful role privilege deletion"); } @@ -307,7 +318,7 @@ async fn test_delete_role_privilege_without_permission() { PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); test_forbidden( &permission_service - .delete_role_privilege("testrole", "testprivilege") + .delete_role_privilege("testrole", "testprivilege", ()) .await, ); } @@ -325,7 +336,7 @@ async fn test_delete_user_role() { PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); permission_service - .delete_user_role("testuser", "testrole") + .delete_user_role("testuser", "testrole", ()) .await .expect("Extected successful user role deletion"); } @@ -337,7 +348,7 @@ async fn test_delete_user_role_without_permission() { PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); test_forbidden( &permission_service - .delete_user_role("testuser", "testrole") + .delete_user_role("testuser", "testrole", ()) .await, ); } @@ -360,7 +371,7 @@ async fn test_all_roles() { PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); let all_roles = permission_service - .get_all_roles() + .get_all_roles(()) .await .expect("Expected roles successfully"); assert_eq!(all_roles.len(), 2); @@ -373,7 +384,7 @@ async fn test_all_roles_without_permission() { let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin"); let permission_service = PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); - test_forbidden(&permission_service.get_all_roles().await); + test_forbidden(&permission_service.get_all_roles(()).await); } #[tokio::test] @@ -394,7 +405,7 @@ async fn test_all_users() { PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); let all_users = permission_service - .get_all_users() + .get_all_users(()) .await .expect("Expected users successfully"); @@ -408,7 +419,7 @@ async fn test_all_users_without_permission() { let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin"); let permission_service = PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); - test_forbidden(&permission_service.get_all_users().await); + test_forbidden(&permission_service.get_all_users(()).await); } #[tokio::test] @@ -432,7 +443,7 @@ async fn test_all_privileges() { PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); let all_privileges = permission_service - .get_all_privileges() + .get_all_privileges(()) .await .expect("Expected privileges successfully"); @@ -446,5 +457,5 @@ async fn test_all_privileges_without_permission() { let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin"); let permission_service = PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service)); - test_forbidden(&permission_service.get_all_privileges().await); + test_forbidden(&permission_service.get_all_privileges(()).await); } diff --git a/service_impl/src/test/slot.rs b/service_impl/src/test/slot.rs index 8621303..18dcfdc 100644 --- a/service_impl/src/test/slot.rs +++ b/service_impl/src/test/slot.rs @@ -72,8 +72,8 @@ pub fn build_dependencies(permission: bool, role: &'static str) -> SlotServiceDe let mut permission_service = MockPermissionService::new(); permission_service .expect_check_permission() - .with(eq(role)) - .returning(move |_| { + .with(eq(role), eq(())) + .returning(move |_, _| { if permission { Ok(()) } else { @@ -82,7 +82,7 @@ pub fn build_dependencies(permission: bool, role: &'static str) -> SlotServiceDe }); permission_service .expect_check_permission() - .returning(move |_| Err(service::ServiceError::Forbidden)); + .returning(move |_, _| Err(service::ServiceError::Forbidden)); let mut clock_service = MockClockService::new(); clock_service .expect_time_now() @@ -122,7 +122,7 @@ async fn test_get_slots() { let slot_service = dependencies.build_service(); - let result = slot_service.get_slots().await; + let result = slot_service.get_slots(()).await; assert!(result.is_ok()); let result = result.unwrap(); @@ -146,7 +146,7 @@ async fn test_get_slots_sales_role() { .expect_get_slots() .returning(|| Ok(Arc::new([]))); let slot_service = dependencies.build_service(); - let result = slot_service.get_slots().await; + let result = slot_service.get_slots(()).await; assert!(result.is_ok()); } @@ -158,7 +158,7 @@ async fn test_get_slots_no_permission() { .expect_get_slots() .returning(|| Ok(Arc::new([]))); let slot_service = dependencies.build_service(); - let result = slot_service.get_slots().await; + let result = slot_service.get_slots(()).await; test_forbidden(&result); } @@ -172,7 +172,7 @@ async fn test_get_slot() { .times(1) .returning(|_| Ok(Some(generate_default_slot_entity()))); let slot_service = dependencies.build_service(); - let result = slot_service.get_slot(&default_id()).await; + let result = slot_service.get_slot(&default_id(), ()).await; assert!(result.is_ok()); let result = result.unwrap(); assert_eq!(result, generate_default_slot()); @@ -188,7 +188,7 @@ async fn test_get_slot_sales_role() { .times(1) .returning(|_| Ok(Some(generate_default_slot_entity()))); let slot_service = dependencies.build_service(); - let result = slot_service.get_slot(&default_id()).await; + let result = slot_service.get_slot(&default_id(), ()).await; assert!(result.is_ok()); } @@ -202,7 +202,7 @@ async fn test_get_slot_not_found() { .times(1) .returning(|_| Ok(None)); let slot_service = dependencies.build_service(); - let result = slot_service.get_slot(&default_id()).await; + let result = slot_service.get_slot(&default_id(), ()).await; test_not_found(&result, &default_id()); } @@ -210,7 +210,7 @@ async fn test_get_slot_not_found() { async fn test_get_slot_no_permission() { let dependencies = build_dependencies(false, "hr"); let slot_service = dependencies.build_service(); - let result = slot_service.get_slot(&default_id()).await; + let result = slot_service.get_slot(&default_id(), ()).await; test_forbidden(&result); } @@ -240,11 +240,14 @@ async fn test_create_slot() { let slot_service = dependencies.build_service(); let result = slot_service - .create_slot(&Slot { - id: Uuid::nil(), - version: Uuid::nil(), - ..generate_default_slot() - }) + .create_slot( + &Slot { + id: Uuid::nil(), + version: Uuid::nil(), + ..generate_default_slot() + }, + (), + ) .await; assert!(result.is_ok()); assert_eq!(result.unwrap(), generate_default_slot()); @@ -254,7 +257,7 @@ async fn test_create_slot() { async fn test_create_slot_no_permission() { let dependencies = build_dependencies(false, "hr"); let slot_service = dependencies.build_service(); - let result = slot_service.create_slot(&generate_default_slot()).await; + let result = slot_service.create_slot(&generate_default_slot(), ()).await; test_forbidden(&result); } @@ -273,10 +276,13 @@ async fn test_create_slot_non_zero_id() { .returning(|_| default_version()); let slot_service = dependencies.build_service(); let result = slot_service - .create_slot(&Slot { - version: Uuid::nil(), - ..generate_default_slot() - }) + .create_slot( + &Slot { + version: Uuid::nil(), + ..generate_default_slot() + }, + (), + ) .await; test_zero_id_error(&result); } @@ -296,10 +302,13 @@ async fn test_create_slot_non_zero_version() { .returning(|_| default_version()); let slot_service = dependencies.build_service(); let result = slot_service - .create_slot(&Slot { - id: Uuid::nil(), - ..generate_default_slot() - }) + .create_slot( + &Slot { + id: Uuid::nil(), + ..generate_default_slot() + }, + (), + ) .await; test_zero_version_error(&result); } @@ -343,85 +352,106 @@ async fn test_create_slot_intersects() { // Test successful case, directly between two existing slots. let result = slot_service - .create_slot(&Slot { - id: Uuid::nil(), - version: Uuid::nil(), - from: Time::from_hms(11, 0, 0).unwrap(), - to: Time::from_hms(12, 0, 0).unwrap(), - ..generate_default_slot() - }) + .create_slot( + &Slot { + id: Uuid::nil(), + version: Uuid::nil(), + from: Time::from_hms(11, 0, 0).unwrap(), + to: Time::from_hms(12, 0, 0).unwrap(), + ..generate_default_slot() + }, + (), + ) .await; assert!(result.is_ok()); // Test case where it is exactly on an existing slot. let result = slot_service - .create_slot(&Slot { - id: Uuid::nil(), - version: Uuid::nil(), - from: Time::from_hms(10, 0, 0).unwrap(), - to: Time::from_hms(11, 0, 0).unwrap(), - ..generate_default_slot() - }) + .create_slot( + &Slot { + id: Uuid::nil(), + version: Uuid::nil(), + from: Time::from_hms(10, 0, 0).unwrap(), + to: Time::from_hms(11, 0, 0).unwrap(), + ..generate_default_slot() + }, + (), + ) .await; test_overlapping_time_range_error(&result); // Test case where from is inside an existing slot. let result = slot_service - .create_slot(&Slot { - id: Uuid::nil(), - version: Uuid::nil(), - from: Time::from_hms(10, 30, 0).unwrap(), - to: Time::from_hms(11, 30, 0).unwrap(), - ..generate_default_slot() - }) + .create_slot( + &Slot { + id: Uuid::nil(), + version: Uuid::nil(), + from: Time::from_hms(10, 30, 0).unwrap(), + to: Time::from_hms(11, 30, 0).unwrap(), + ..generate_default_slot() + }, + (), + ) .await; test_overlapping_time_range_error(&result); // Test case where to is inside an existing slot. let result = slot_service - .create_slot(&Slot { - id: Uuid::nil(), - version: Uuid::nil(), - from: Time::from_hms(11, 30, 0).unwrap(), - to: Time::from_hms(12, 30, 0).unwrap(), - ..generate_default_slot() - }) + .create_slot( + &Slot { + id: Uuid::nil(), + version: Uuid::nil(), + from: Time::from_hms(11, 30, 0).unwrap(), + to: Time::from_hms(12, 30, 0).unwrap(), + ..generate_default_slot() + }, + (), + ) .await; test_overlapping_time_range_error(&result); // Test case where is completely inside an existing slot. let result = slot_service - .create_slot(&Slot { - id: Uuid::nil(), - version: Uuid::nil(), - from: Time::from_hms(10, 15, 0).unwrap(), - to: Time::from_hms(10, 45, 0).unwrap(), - ..generate_default_slot() - }) + .create_slot( + &Slot { + id: Uuid::nil(), + version: Uuid::nil(), + from: Time::from_hms(10, 15, 0).unwrap(), + to: Time::from_hms(10, 45, 0).unwrap(), + ..generate_default_slot() + }, + (), + ) .await; test_overlapping_time_range_error(&result); // Test case where is completely outside of an existing slot. let result = slot_service - .create_slot(&Slot { - id: Uuid::nil(), - version: Uuid::nil(), - from: Time::from_hms(9, 0, 0).unwrap(), - to: Time::from_hms(11, 0, 0).unwrap(), - ..generate_default_slot() - }) + .create_slot( + &Slot { + id: Uuid::nil(), + version: Uuid::nil(), + from: Time::from_hms(9, 0, 0).unwrap(), + to: Time::from_hms(11, 0, 0).unwrap(), + ..generate_default_slot() + }, + (), + ) .await; test_overlapping_time_range_error(&result); // Test case where is would intersect on monday but not on tuesday. // Test case where is completely outside of an existing slot. let result = slot_service - .create_slot(&Slot { - id: Uuid::nil(), - version: Uuid::nil(), - day_of_week: DayOfWeek::Tuesday.into(), - ..generate_default_slot() - }) + .create_slot( + &Slot { + id: Uuid::nil(), + version: Uuid::nil(), + day_of_week: DayOfWeek::Tuesday.into(), + ..generate_default_slot() + }, + (), + ) .await; assert!(result.is_ok()); } @@ -440,13 +470,16 @@ async fn test_create_slot_time_order() { let slot_service = dependencies.build_service(); let result = slot_service - .create_slot(&Slot { - id: Uuid::nil(), - version: Uuid::nil(), - from: Time::from_hms(12, 00, 0).unwrap(), - to: Time::from_hms(11, 00, 00).unwrap(), - ..generate_default_slot() - }) + .create_slot( + &Slot { + id: Uuid::nil(), + version: Uuid::nil(), + from: Time::from_hms(12, 00, 0).unwrap(), + to: Time::from_hms(11, 00, 00).unwrap(), + ..generate_default_slot() + }, + (), + ) .await; test_time_order_wrong(&result); } @@ -465,13 +498,16 @@ async fn test_create_slot_date_order() { let slot_service = dependencies.build_service(); let result = slot_service - .create_slot(&Slot { - id: Uuid::nil(), - version: Uuid::nil(), - valid_from: Date::from_calendar_date(2022, Month::January, 2).unwrap(), - valid_to: Some(Date::from_calendar_date(2022, Month::January, 1).unwrap()), - ..generate_default_slot() - }) + .create_slot( + &Slot { + id: Uuid::nil(), + version: Uuid::nil(), + valid_from: Date::from_calendar_date(2022, Month::January, 2).unwrap(), + valid_to: Some(Date::from_calendar_date(2022, Month::January, 1).unwrap()), + ..generate_default_slot() + }, + (), + ) .await; test_date_order_wrong(&result); } @@ -502,7 +538,7 @@ async fn test_delete_slot() { .returning(|_, _| Ok(())); let slot_service = dependencies.build_service(); - let result = slot_service.delete_slot(&default_id()).await; + let result = slot_service.delete_slot(&default_id(), ()).await; assert!(result.is_ok()); } @@ -510,7 +546,7 @@ async fn test_delete_slot() { async fn test_delete_slot_no_permission() { let dependencies = build_dependencies(false, "hr"); let slot_service = dependencies.build_service(); - let result = slot_service.delete_slot(&default_id()).await; + let result = slot_service.delete_slot(&default_id(), ()).await; test_forbidden(&result); } @@ -524,7 +560,7 @@ async fn test_delete_slot_not_found() { .times(1) .returning(|_| Ok(None)); let slot_service = dependencies.build_service(); - let result = slot_service.delete_slot(&default_id()).await; + let result = slot_service.delete_slot(&default_id(), ()).await; test_not_found(&result, &default_id()); } @@ -532,7 +568,7 @@ async fn test_delete_slot_not_found() { async fn test_update_slot_no_permission() { let dependencies = build_dependencies(false, "hr"); let slot_service = dependencies.build_service(); - let result = slot_service.update_slot(&generate_default_slot()).await; + let result = slot_service.update_slot(&generate_default_slot(), ()).await; test_forbidden(&result); } @@ -546,7 +582,7 @@ async fn test_update_slot_not_found() { .times(1) .returning(|_| Ok(None)); let slot_service = dependencies.build_service(); - let result = slot_service.update_slot(&generate_default_slot()).await; + let result = slot_service.update_slot(&generate_default_slot(), ()).await; test_not_found(&result, &default_id()); } @@ -560,10 +596,13 @@ async fn test_update_slot_version_mismatch() { .returning(|_| Ok(Some(generate_default_slot_entity()))); let slot_service = dependencies.build_service(); let result = slot_service - .update_slot(&service::slot::Slot { - version: uuid!("86DE856C-D176-4F1F-A4FE-0D9844C02C04"), - ..generate_default_slot() - }) + .update_slot( + &service::slot::Slot { + version: uuid!("86DE856C-D176-4F1F-A4FE-0D9844C02C04"), + ..generate_default_slot() + }, + (), + ) .await; test_conflicts( &result, @@ -605,12 +644,15 @@ async fn test_update_slot_valid_to() { let slot_service = dependencies.build_service(); let result = slot_service - .update_slot(&service::slot::Slot { - valid_to: Some( - time::Date::from_calendar_date(2022, 1.try_into().unwrap(), 10).unwrap(), - ), - ..generate_default_slot() - }) + .update_slot( + &service::slot::Slot { + valid_to: Some( + time::Date::from_calendar_date(2022, 1.try_into().unwrap(), 10).unwrap(), + ), + ..generate_default_slot() + }, + (), + ) .await; dbg!(&result); assert!(result.is_ok()); @@ -627,12 +669,15 @@ async fn test_update_slot_valid_to_before_valid_from() { let slot_service = dependencies.build_service(); let result = slot_service - .update_slot(&service::slot::Slot { - valid_to: Some( - time::Date::from_calendar_date(2021, 1.try_into().unwrap(), 10).unwrap(), - ), - ..generate_default_slot() - }) + .update_slot( + &service::slot::Slot { + valid_to: Some( + time::Date::from_calendar_date(2021, 1.try_into().unwrap(), 10).unwrap(), + ), + ..generate_default_slot() + }, + (), + ) .await; test_date_order_wrong(&result); } @@ -669,13 +714,16 @@ async fn test_update_slot_deleted() { let slot_service = dependencies.build_service(); let result = slot_service - .update_slot(&Slot { - deleted: Some(time::PrimitiveDateTime::new( - Date::from_calendar_date(2022, 1.try_into().unwrap(), 10).unwrap(), - Time::from_hms(0, 0, 0).unwrap(), - )), - ..generate_default_slot() - }) + .update_slot( + &Slot { + deleted: Some(time::PrimitiveDateTime::new( + Date::from_calendar_date(2022, 1.try_into().unwrap(), 10).unwrap(), + Time::from_hms(0, 0, 0).unwrap(), + )), + ..generate_default_slot() + }, + (), + ) .await; assert!(result.is_ok()); } @@ -690,10 +738,13 @@ async fn test_update_slot_day_of_week_forbidden() { .returning(|_| Ok(Some(generate_default_slot_entity()))); let slot_service = dependencies.build_service(); let result = slot_service - .update_slot(&service::slot::Slot { - day_of_week: service::slot::DayOfWeek::Friday, - ..generate_default_slot() - }) + .update_slot( + &service::slot::Slot { + day_of_week: service::slot::DayOfWeek::Friday, + ..generate_default_slot() + }, + (), + ) .await; test_validation_error( &result, @@ -719,10 +770,15 @@ async fn test_update_to_forbidden_when_not_none() { }); let slot_service = dependencies.build_service(); let result = slot_service - .update_slot(&service::slot::Slot { - valid_to: Some(time::Date::from_calendar_date(2022, 1.try_into().unwrap(), 4).unwrap()), - ..generate_default_slot() - }) + .update_slot( + &service::slot::Slot { + valid_to: Some( + time::Date::from_calendar_date(2022, 1.try_into().unwrap(), 4).unwrap(), + ), + ..generate_default_slot() + }, + (), + ) .await; test_validation_error( &result, @@ -741,10 +797,13 @@ async fn test_update_from_forbidden() { .returning(|_| Ok(Some(generate_default_slot_entity()))); let slot_service = dependencies.build_service(); let result = slot_service - .update_slot(&service::slot::Slot { - from: time::Time::from_hms(14, 0, 0).unwrap(), - ..generate_default_slot() - }) + .update_slot( + &service::slot::Slot { + from: time::Time::from_hms(14, 0, 0).unwrap(), + ..generate_default_slot() + }, + (), + ) .await; test_validation_error( &result, @@ -763,10 +822,13 @@ async fn test_update_to_forbidden() { .returning(|_| Ok(Some(generate_default_slot_entity()))); let slot_service = dependencies.build_service(); let result = slot_service - .update_slot(&service::slot::Slot { - to: time::Time::from_hms(14, 0, 0).unwrap(), - ..generate_default_slot() - }) + .update_slot( + &service::slot::Slot { + to: time::Time::from_hms(14, 0, 0).unwrap(), + ..generate_default_slot() + }, + (), + ) .await; test_validation_error( &result, @@ -785,10 +847,14 @@ async fn test_update_valid_from_forbidden() { .returning(|_| Ok(Some(generate_default_slot_entity()))); let slot_service = dependencies.build_service(); let result = slot_service - .update_slot(&service::slot::Slot { - valid_from: time::Date::from_calendar_date(2022, 1.try_into().unwrap(), 10).unwrap(), - ..generate_default_slot() - }) + .update_slot( + &service::slot::Slot { + valid_from: time::Date::from_calendar_date(2022, 1.try_into().unwrap(), 10) + .unwrap(), + ..generate_default_slot() + }, + (), + ) .await; test_validation_error( &result, @@ -807,11 +873,15 @@ async fn test_update_valid_multiple_forbidden_changes() { .returning(|_| Ok(Some(generate_default_slot_entity()))); let slot_service = dependencies.build_service(); let result = slot_service - .update_slot(&service::slot::Slot { - valid_from: time::Date::from_calendar_date(2022, 1.try_into().unwrap(), 10).unwrap(), - from: time::Time::from_hms(14, 0, 0).unwrap(), - ..generate_default_slot() - }) + .update_slot( + &service::slot::Slot { + valid_from: time::Date::from_calendar_date(2022, 1.try_into().unwrap(), 10) + .unwrap(), + from: time::Time::from_hms(14, 0, 0).unwrap(), + ..generate_default_slot() + }, + (), + ) .await; test_validation_error( &result,