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.
{% 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 }},
    modelo::{{ pascal }},
    repositorio::Repositorio{{ pascal }},
};

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

#[async_trait]
impl Obtener{{ pascal }} for Obtener{{ pascal }}Impl {
    async fn ejecutar(&self, params: ParamsObtener{{ pascal }}) -> Result<{{ pascal }}, Error{{ pascal }}> {
        tracing::info!(id = %params.id, "obtener_{{ snake }}: inicio");
        let resultado = self.repositorio.buscar_por_id(params.id).await.inspect_err(|e| tracing::error!(error = %e, "obtener_{{ snake }}: fallo del repositorio"))?;
        resultado.ok_or_else(|| {
            let err = Error{{ pascal }}::NoEncontrado;
            tracing::warn!(error = %err, "obtener_{{ snake }}: rechazado");
            err
        })
    }
}

#[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 }},
    };
    use puerto_nucleo::ErrorRepositorio;


    #[tokio::test]
    async fn deberia_devolver_{{ snake }}_cuando_el_id_existe() {
        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 caso_de_uso = Obtener{{ pascal }}Impl {
            repositorio: Arc::new(repositorio_doble),
        };

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

        assert_eq!(resultado.unwrap().id, id_entidad);
    }

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

        let resultado = caso_de_uso
            .ejecutar(ParamsObtener{{ 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");
    }

    #[tokio::test]
    async fn deberia_devolver_error_de_repositorio_cuando_el_almacen_no_esta_disponible() {
        let mut repositorio_doble = MockRepositorio{{ pascal }}::new();
        repositorio_doble
            .expect_buscar_por_id()
            .returning(|_| Err(ErrorRepositorio::NoDisponible));
        let caso_de_uso = Obtener{{ pascal }}Impl {
            repositorio: Arc::new(repositorio_doble),
        };

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

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