vanikam/src/ordering/application/services/add_kot_service.rs

// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
//
// SPDX-License-Identifier: AGPL-3.0-or-later

use std::sync::Arc;

use derive_builder::Builder;
use mockall::predicate::*;
use mockall::*;

use super::errors::*;
use crate::ordering::{
    application::port::output::db::kot_id_exists::*,
    application::port::output::db::order_id_exists::*,
    domain::{add_kot_command::*, kot_added_event::*, kot_aggregate::*},
};

#[automock]
#[async_trait::async_trait]
pub trait AddKotUseCase: Send + Sync {
    async fn add_kot(&self, cmd: AddKotCommand) -> OrderingResult<KotAddedEvent>;
}

pub type AddKotServiceObj = Arc<dyn AddKotUseCase>;

#[derive(Clone, Builder)]
pub struct AddKotService {
    db_kot_id_exists: KotIDExistsDBPortObj,
    db_order_id_exists: OrderIDExistsDBPortObj,
}

#[async_trait::async_trait]
impl AddKotUseCase for AddKotService {
    async fn add_kot(&self, cmd: AddKotCommand) -> OrderingResult<KotAddedEvent> {
        if !self
            .db_order_id_exists
            .order_id_exists(cmd.order_id())
            .await?
        {
            return Err(OrderingError::OrderIDNotFound);
        }

        if self.db_kot_id_exists.kot_id_exists(cmd.kot_id()).await? {
            return Err(OrderingError::KotIDNotFound);
        }

        let kot = KotBuilder::default()
            .created_time(cmd.created_time().clone())
            .order_id(*cmd.order_id())
            .kot_id(*cmd.kot_id())
            .deleted(false)
            .build()
            .unwrap();

        Ok(KotAddedEventBuilder::default()
            .added_by_user(*cmd.adding_by())
            .kot(kot)
            .build()
            .unwrap())
    }
}

#[cfg(test)]
pub mod tests {
    use super::*;

    use crate::ordering::domain::kot_added_event::tests::get_added_kot_event_from_command;
    use crate::tests::bdd::*;
    use crate::utils::uuid::tests::UUID;

    pub fn mock_add_kot_service(times: Option<usize>, cmd: AddKotCommand) -> AddKotServiceObj {
        let mut m = MockAddKotUseCase::new();

        let res = get_added_kot_event_from_command(&cmd);
        if let Some(times) = times {
            m.expect_add_kot()
                .times(times)
                .returning(move |_| Ok(res.clone()));
        } else {
            m.expect_add_kot().returning(move |_| Ok(res.clone()));
        }

        Arc::new(m)
    }

    #[actix_rt::test]
    async fn test_service() {
        let cmd = AddKotCommand::get_cmd();

        let s = AddKotServiceBuilder::default()
            .db_kot_id_exists(mock_kot_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
            .db_order_id_exists(mock_order_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
            .build()
            .unwrap();

        let res = s.add_kot(cmd.clone()).await.unwrap();
        assert_eq!(res.kot().order_id(), cmd.order_id());
        assert!(!res.kot().deleted());
        assert_eq!(res.kot().created_time(), cmd.created_time());
        assert_eq!(res.added_by_user(), cmd.adding_by());
    }

    #[actix_rt::test]
    async fn test_service_order_id_doesnt_exist() {
        let cmd = AddKotCommand::get_cmd();

        let s = AddKotServiceBuilder::default()
            .db_kot_id_exists(mock_kot_id_exists_db_port_false(IS_NEVER_CALLED))
            .db_order_id_exists(mock_order_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
            .build()
            .unwrap();

        assert_eq!(
            s.add_kot(cmd.clone()).await,
            Err(OrderingError::OrderIDNotFound)
        );
    }
}