puerto 0.22.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.
use std::sync::Arc;

use async_trait::async_trait;
use puerto_nucleo::ErrorRepositorio;

use dominio_{{ snake }}::{
    errores::Error{{ pascal }},
    eventos::{{ "{" }}Evento{{ pascal }}, Snapshot{{ pascal }}},
    repositorio::Repositorio{{ pascal }},
    unit_of_work::UnitOfWorkFactory{{ pascal }},
};

pub struct Borrar{{ pascal }}Impl {
    pub repositorio: Arc<dyn Repositorio{{ pascal }}>,
    pub uow_factory: Arc<dyn UnitOfWorkFactory{{ 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 fallido = |e: &ErrorRepositorio| tracing::error!(error = %e, "borrar_{{ snake }}: fallo del repositorio");
        let mut entidad = self
            .repositorio
            .buscar_por_id(params.id)
            .await
            .inspect_err(fallido)?
            .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;
        let mut uow = self.uow_factory.begin().await.inspect_err(fallido)?;
        uow.guardar(&entidad).await.inspect_err(fallido)?;
        uow.registrar(Evento{{ pascal }}::Borrado(Snapshot{{ pascal }}::from_entidad(&entidad))).await.inspect_err(fallido)?;
        uow.commit().await.inspect_err(fallido)?;
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
{% if actor %}    use puerto_nucleo::auth::dobles::MadrePrincipal;
{% endif %}    use dominio_{{ snake }}::{
        modelo::Id{{ pascal }},
        pruebas::madres::Madre{{ pascal }},
        repositorio::dobles::MockRepositorio{{ pascal }},
        unit_of_work::dobles::UnitOfWorkFactoryGrabadora,
    };
    use puerto_nucleo::EventoDominio;


    #[tokio::test]
    async fn deberia_registrar_el_evento_{{ snake }}_borrado_cuando_el_id_existe() {
        // Preparar
        let entidad = Madre{{ pascal }}::aleatorio();
        let id_entidad = entidad.id;
        let mut repositorio_doble = MockRepositorio{{ pascal }}::new();
        repositorio_doble
            .expect_buscar_por_id()
            .returning(move |_| Ok(Some(entidad.clone())));
        let uow_factory = UnitOfWorkFactoryGrabadora::new();
        let caso_de_uso = Borrar{{ pascal }}Impl {
            repositorio: Arc::new(repositorio_doble),
            uow_factory: Arc::new(uow_factory.clone()),
        };

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

        // Comprobar
        assert!(resultado.is_ok());
        let grabado = uow_factory.grabado();
        assert!(grabado.confirmado);
        assert!(grabado.guardados.iter().all(|guardados| guardados.borrado));
        assert_eq!(grabado.eventos.len(), 1);
        assert_eq!(grabado.eventos[0].tipo_evento(), "{{ snake }}_borrado");
        assert_eq!(grabado.eventos[0].id_agregado(), id_entidad.valor());
    }

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

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

        // Comprobar
        assert!(resultado.is_err());
        assert_eq!(resultado.unwrap_err().to_string(), "{{ snake }}.no_encontrado");
        assert!(uow_factory.grabado().eventos.is_empty());
    }
}