puerto 0.21.0

Puerto — Rust full-stack DDD framework CLI. Scaffolds Clean Architecture projects with auto-wired DI, SQLx support, and zero manual wiring. Formerly puerto-framework.
{% 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 dominio_{{ snake }}::{
    errores::Error{{ pascal }},
    repositorio::Repositorio{{ pascal }},
};

pub struct Borrar{{ pascal }}Impl {
    pub repositorio: Arc<dyn Repositorio{{ pascal }}>,
}

#[async_trait]
impl Borrar{{ pascal }} for Borrar{{ pascal }}Impl {
    async fn ejecutar(&self, params: ParamsBorrar{{ pascal }}) -> Result<(), Error{{ pascal }}> {
        tracing::info!(id = %params.id, "borrar_{{ snake }}: inicio");
        let mut entidad = self
            .repositorio
            .buscar_por_id(params.id)
            .await
            .inspect_err(|e| tracing::error!(error = %e, "borrar_{{ snake }}: fallo del repositorio"))?
            .ok_or_else(|| {
                let err = Error{{ pascal }}::NoEncontrado;
                tracing::warn!(error = %err, "borrar_{{ snake }}: rechazado");
                err
            })?;
        let ahora = chrono::Utc::now();
        entidad.borrado = true;
        entidad.borrado_en = Some(ahora);
        entidad.actualizado_en = ahora;
        self.repositorio.guardar(&entidad).await.inspect_err(|e| tracing::error!(error = %e, "borrar_{{ snake }}: fallo del repositorio"))?;
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
{% if actor %}    use puerto_nucleo::auth::dobles::MadrePrincipal;
{% endif %}    use dominio_{{ snake }}::{
        modelo::{{ "{" }}{{ pascal }}, Id{{ pascal }}, Props{{ pascal }}},
        repositorio::dobles::MockRepositorio{{ pascal }},
    };
{% for import in test_imports %}    use {{ import }};
{% endfor %}

    #[tokio::test]
    async fn deberia_hacer_borrado_logico_de_{{ snake }}_cuando_el_id_existe() {
        let entidad = {{ pascal }}::new(Props{{ pascal }} {
{{ macros::props(fields=fields, word="example") }}        }).unwrap();
        let id_entidad = entidad.id;
        let mut repositorio_doble = MockRepositorio{{ pascal }}::new();
        repositorio_doble
            .expect_buscar_por_id()
            .returning(move |_| Ok(Some(entidad.clone())));
        repositorio_doble.expect_guardar().returning(|_| Ok(()));
        let caso_de_uso = Borrar{{ pascal }}Impl {
            repositorio: Arc::new(repositorio_doble),
        };

        let resultado = caso_de_uso
            .ejecutar(ParamsBorrar{{ pascal }} { {% if actor %}actor: MadrePrincipal::aleatorio(), {% endif %}id: id_entidad })
            .await;

        assert!(resultado.is_ok());
    }

    #[tokio::test]
    async fn deberia_devolver_no_encontrado_cuando_{{ snake }}_no_existe() {
        let mut repositorio_doble = MockRepositorio{{ pascal }}::new();
        repositorio_doble.expect_buscar_por_id().returning(|_| Ok(None));
        let caso_de_uso = Borrar{{ pascal }}Impl {
            repositorio: Arc::new(repositorio_doble),
        };

        let resultado = caso_de_uso
            .ejecutar(ParamsBorrar{{ pascal }} { {% if actor %}actor: MadrePrincipal::aleatorio(), {% endif %}id: Id{{ pascal }}::generar() })
            .await;

        assert!(resultado.is_err());
        assert_eq!(resultado.unwrap_err().to_string(), "{{ snake }}.no_encontrado");
    }
}