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

12
app/src/main.rs
View file

@ -4,7 +4,6 @@ use sqlx::SqlitePool;
type PermissionService =
service_impl::PermissionServiceImpl<dao_impl::PermissionDaoImpl, service_impl::UserServiceDev>;
type HelloService = service_impl::HelloServiceImpl<dao_impl::HelloDaoImpl, PermissionService>;
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<HelloService>,
permission_service: Arc<PermissionService>,
slot_service: Arc<SlotService>,
}
impl rest::RestStateDef for RestStateImpl {
type HelloService = HelloService;
type PermissionService = PermissionService;
type SlotService = SlotService;
fn hello_service(&self) -> Arc<Self::HelloService> {
self.hello_service.clone()
}
fn permission_service(&self) -> Arc<Self::PermissionService> {
self.permission_service.clone()
}
@ -37,7 +31,6 @@ impl rest::RestStateDef for RestStateImpl {
}
impl RestStateImpl {
pub fn new(pool: Arc<sqlx::Pool<sqlx::Sqlite>>) -> 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,
}

14
rest/src/hello.rs
View file

@ -1,14 +0,0 @@
use axum::{extract::State, response::Response};
use crate::{error_handler, RestStateDef, RoString};
use service::HelloService;
pub async fn hello<RestState: RestStateDef>(State(rest_state): State<RestState>) -> Response {
error_handler(
(async {
let string = rest_state.hello_service().hello().await?;
Ok(RoString::from(string).into())
})
.await,
)
}

13
rest/src/lib.rs
View file

@ -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<str>, bool);
impl http_body::Body for RoString {
type Data = bytes::Bytes;
@ -125,18 +127,15 @@ fn error_handler(result: Result<Response, RestError>) -> 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<Context = Context> + Send + Sync + 'static;
type SlotService: service::slot::SlotService<Context = Context> + Send + Sync + 'static;
fn hello_service(&self) -> Arc<Self::HelloService>;
fn permission_service(&self) -> Arc<Self::PermissionService>;
fn slot_service(&self) -> Arc<Self::SlotService>;
}
pub async fn start_server<RestState: RestStateDef>(rest_state: RestState) {
let app = Router::new()
.route("/", get(hello::hello::<RestState>))
.nest("/permission", permission::generate_route())
.nest("/slot", slot::generate_route())
.with_state(rest_state);

23
rest/src/permission.rs
View file

@ -87,7 +87,7 @@ pub async fn add_user<RestState: RestStateDef>(
(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<RestState: RestStateDef>(
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<RestState: RestStateDef>(
(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<RestState: RestStateDef>(
(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<RestState: RestStateDef>(
(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<RestState: RestStateDef>(
(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<RestState: RestStateDef>(
.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<RestState: RestStateDef>(
.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<RestState: RestStateDef>(rest_state: State<RestState>
(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<RestState: RestStateDef>(rest_state: State<RestState>
(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<RestState: RestStateDef>(rest_state: State<RestS
(async {
let privileges: Arc<[PrivilegeTO]> = rest_state
.permission_service()
.get_all_privileges()
.get_all_privileges(())
.await?
.iter()
.map(PrivilegeTO::from)

8
rest/src/slot.rs
View file

@ -107,7 +107,7 @@ pub async fn get_all_slots<RestState: RestStateDef>(rest_state: State<RestState>
(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<RestState: RestStateDef>(
) -> 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<RestState: RestStateDef>(
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<RestState: RestStateDef>(
}
rest_state
.slot_service()
.update_slot(&(&slot).into())
.update_slot(&(&slot).into(), ())
.await?;
Ok(Response::builder()
.status(200)

16
service/src/lib.rs
View file

@ -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<Output = Result<Arc<str>, ServiceError>> + Send;
}
#[automock]
#[async_trait]
pub trait UserService {
async fn current_user(&self) -> Result<Arc<str>, ServiceError>;
}

67
service/src/permission.rs
View file

@ -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<Arc<[User]>, 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<Arc<[Role]>, 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<Arc<[User]>, 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<Arc<[Privilege]>, 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<Arc<[Role]>, 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<Arc<[Privilege]>, 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>;
}

14
service/src/slot.rs
View file

@ -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<Arc<[Slot]>, ServiceError>;
async fn get_slot(&self, id: &Uuid) -> Result<Slot, ServiceError>;
async fn create_slot(&self, slot: &Slot) -> Result<Slot, ServiceError>;
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<Arc<[Slot]>, ServiceError>;
async fn get_slot(&self, id: &Uuid, context: Self::Context) -> Result<Slot, ServiceError>;
async fn create_slot(&self, slot: &Slot, context: Self::Context) -> Result<Slot, ServiceError>;
async fn delete_slot(&self, id: &Uuid, context: Self::Context) -> Result<(), ServiceError>;
async fn update_slot(&self, slot: &Slot, context: Self::Context) -> Result<(), ServiceError>;
}

14
service/src/user_service.rs Normal file
View file

@ -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<Arc<str>, ServiceError>;
}

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,