Shifty/shifty-backend
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add context reqruied later for authentication

Browse source
This commit is contained in:
Simon Goller 2024-05-03 19:01:26 +02:00
parent 9a367c9260
commit 20828fb4a1
14 changed files with 463 additions and 330 deletions
Download patch file Download diff file Expand all files Collapse all files

42
service_impl/src/lib.rs
View file

@ -10,44 +10,16 @@ pub mod uuid_service;
pub use permission::PermissionServiceImpl;
pub struct HelloServiceImpl<HelloDao, PermissionService>
where
HelloDao: dao::HelloDao + Sync + Send,
PermissionService: service::PermissionService + Sync + Send,
{
hello_dao: Arc<HelloDao>,
permission_service: Arc<PermissionService>,
}
impl<HelloDao, PermissionService> HelloServiceImpl<HelloDao, PermissionService>
where
HelloDao: dao::HelloDao + Sync + Send,
PermissionService: service::PermissionService + Sync + Send,
{
pub fn new(hello_dao: Arc<HelloDao>, permission_service: Arc<PermissionService>) -> Self {
Self {
hello_dao,
permission_service,
}
}
}
impl<HelloDao, PermissionService> service::HelloService
for HelloServiceImpl<HelloDao, PermissionService>
where
HelloDao: dao::HelloDao + Sync + Send,
PermissionService: service::PermissionService + Sync + Send,
{
async fn hello(&self) -> Result<Arc<str>, 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<Arc<str>, service::ServiceError> {
impl service::user_service::UserService for UserServiceDev {
type Context = ();
async fn current_user(
&self,
_context: Self::Context,
) -> Result<Arc<str>, service::ServiceError> {
Ok("DEVUSER".into())
}
}

109
service_impl/src/permission.rs
View file

@ -5,7 +5,7 @@ use async_trait::async_trait;
pub struct PermissionServiceImpl<PermissionDao, UserService>
where
PermissionDao: dao::PermissionDao + Send + Sync,
UserService: service::UserService + Send + Sync,
UserService: service::user_service::UserService + Send + Sync,
{
permission_dao: Arc<PermissionDao>,
user_service: Arc<UserService>,
@ -13,7 +13,7 @@ where
impl<PermissionDao, UserService> PermissionServiceImpl<PermissionDao, UserService>
where
PermissionDao: dao::PermissionDao + Send + Sync,
UserService: service::UserService + Send + Sync,
UserService: service::user_service::UserService + Send + Sync,
{
pub fn new(permission_dao: Arc<PermissionDao>, user_service: Arc<UserService>) -> Self {
Self {
@ -30,10 +30,16 @@ impl<PermissionDao, UserService> service::PermissionService
for PermissionServiceImpl<PermissionDao, UserService>
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<Arc<[service::User]>, service::ServiceError> {
self.check_permission("admin").await?;
async fn get_all_users(
&self,
context: Self::Context,
) -> Result<Arc<[service::User]>, 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<Arc<[service::Role]>, service::ServiceError> {
self.check_permission("admin").await?;
async fn get_all_roles(
&self,
context: Self::Context,
) -> Result<Arc<[service::Role]>, 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<Arc<[service::Privilege]>, service::ServiceError> {
self.check_permission("admin").await?;
async fn get_all_privileges(
&self,
context: Self::Context,
) -> Result<Arc<[service::Privilege]>, 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(())
}

36
service_impl/src/slot.rs
View file

@ -58,10 +58,13 @@ where
ClockService: service::clock::ClockService + Send + Sync,
UuidService: service::uuid_service::UuidService + Send + Sync,
{
async fn get_slots(&self) -> Result<Arc<[Slot]>, ServiceError> {
type Context = PermissionService::Context;
async fn get_slots(&self, context: Self::Context) -> Result<Arc<[Slot]>, 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<Slot, ServiceError> {
async fn get_slot(&self, id: &Uuid, context: Self::Context) -> Result<Slot, 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)?;
@ -87,8 +91,10 @@ where
.ok_or_else(move || ServiceError::EntityNotFound(*id))?;
Ok(slot)
}
async fn create_slot(&self, slot: &Slot) -> Result<Slot, ServiceError> {
self.permission_service.check_permission("hr").await?;
async fn create_slot(&self, slot: &Slot, context: Self::Context) -> Result<Slot, ServiceError> {
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)

77
service_impl/src/test/permission_test.rs
View file

@ -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);
}

348
service_impl/src/test/slot.rs
View file

@ -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,