puerto 0.19.0

{% import "application/macros.tera" as macros %}{% set required = fields | filter(attribute="required_string", value=true) %}{% set string_vos = fields | filter(attribute="string_vo", value=true) %}use std::sync::Arc;

use async_trait::async_trait;

use crate::domain::{{ snake }}::{
    errors::{{ pascal }}Error,
    repository::{{ pascal }}RepositoryTrait,
    use_cases::delete_{{ snake }}::{Delete{{ pascal }}Params, Delete{{ pascal }}UseCaseTrait},
};

pub struct Delete{{ pascal }}UseCaseImpl {
    pub repository: Arc<dyn {{ pascal }}RepositoryTrait>,
}

#[async_trait]
impl Delete{{ pascal }}UseCaseTrait for Delete{{ pascal }}UseCaseImpl {
    async fn execute(&self, params: Delete{{ pascal }}Params) -> Result<(), {{ pascal }}Error> {
        tracing::info!(id = %params.id, "delete_{{ snake }}: start");
        let mut entity = self
            .repository
            .find_by_id(params.id)
            .await
            .inspect_err(|e| tracing::error!(error = %e, "delete_{{ snake }}: repository failed"))?
            .ok_or_else(|| {
                let err = {{ pascal }}Error::NotFound;
                tracing::warn!(error = %err, "delete_{{ snake }}: rejected");
                err
            })?;
        let now = chrono::Utc::now();
        entity.deleted = true;
        entity.deleted_at = Some(now);
        entity.updated_at = now;
        self.repository.save(&entity).await.inspect_err(|e| tracing::error!(error = %e, "delete_{{ snake }}: repository failed"))?;
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
{% if actor %}    use crate::tests::mothers::principal_mother::PrincipalMother;
{% endif %}    use crate::domain::{{ snake }}::{
        model::{{ "{" }}{{ pascal }}, {{ pascal }}Id, {{ pascal }}Props},
        repository::mocks::Mock{{ pascal }}Repository,
    };
{% for import in test_imports %}    use {{ import }};
{% endfor %}

    #[tokio::test]
    async fn should_soft_delete_{{ snake }}_when_id_exists() {
        let entity = {{ pascal }}::new({{ pascal }}Props {
{{ macros::props(fields=fields, word="example") }}        }).unwrap();
        let entity_id = entity.id;
        let mut mock_repo = Mock{{ pascal }}Repository::new();
        mock_repo
            .expect_find_by_id()
            .returning(move |_| Ok(Some(entity.clone())));
        mock_repo.expect_save().returning(|_| Ok(()));
        let use_case = Delete{{ pascal }}UseCaseImpl {
            repository: Arc::new(mock_repo),
        };

        let result = use_case
            .execute(Delete{{ pascal }}Params { {% if actor %}actor: PrincipalMother::random(), {% endif %}id: entity_id })
            .await;

        assert!(result.is_ok());
    }

    #[tokio::test]
    async fn should_return_not_found_when_{{ snake }}_does_not_exist() {
        let mut mock_repo = Mock{{ pascal }}Repository::new();
        mock_repo.expect_find_by_id().returning(|_| Ok(None));
        let use_case = Delete{{ pascal }}UseCaseImpl {
            repository: Arc::new(mock_repo),
        };

        let result = use_case
            .execute(Delete{{ pascal }}Params { {% if actor %}actor: PrincipalMother::random(), {% endif %}id: {{ pascal }}Id::generate() })
            .await;

        assert!(result.is_err());
        assert_eq!(result.unwrap_err().to_string(), "{{ snake }}.not_found");
    }
}